本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 创建和管理基于节点的集群 ElastiCache
如果您需要对集群进行精细控制，则可以创建基于节点的 ElastiCache 集群。 ElastiCache 允许您通过为集群选择节点类型、节点数量和跨AWS可用区的节点放置来操作基于节点的集群。由于 ElastiCache 是一项完全托管的服务，因此它可以自动管理集群的硬件配置、监控、节点更换和软件修补。
有关设置的信息，请参阅[设置 ElastiCache](set-up.md)。有关管理、更新或删除节点或集群的详细信息，请参阅[在 ElastiCache 中管理节点](CacheNodes.md)。有关创建基于节点的 ElastiCache 集群时Amazon ElastiCache 部署的主要组件的概述，请参阅以下[关键](WhatIs.corecomponents.md)概念。
**Topics**
+ [ElastiCache 组件和功能](WhatIs.Components.md)
+ [ElastiCache 术语](WhatIs.Terms.md)
+ [教程：如何创建基于节点的集群 ElastiCache](SubnetGroups.designing-cluster-pre.md)
+ [删除集群](Clusters.Delete-gs.redis.md)
+ [其他 ElastiCache 教程和视频](Tutorials.md)
+ [在 ElastiCache 中管理节点](CacheNodes.md)
+ [在 ElastiCache 中管理集群](Clusters.md)
+ [比较 Valkey、Memcached 和 Redis OSS 基于节点的集群](SelectEngine.md)
+ [Valkey 或 Redis OSS 的在线迁移](OnlineMigration.md)
+ [为 ElastiCache 选择区域和可用区](RegionsAndAZs.md)
# ElastiCache 组件和功能
接下来，您可以找到 Amazon ElastiCache 部署的主要组件的概述。
**Topics**
+ [ElastiCache 节点](#WhatIs.Components.Nodes)
+ [ElastiCache 碎片](#WhatIs.Components.Shards)
+ [ElastiCache 集群](#WhatIs.Components.Clusters)
+ [ElastiCache 复制](#WhatIs.Components.ReplicationGroups)
+ [ElastiCache 端点](#WhatIs.Components.Endpoints)
+ [ElastiCache 参数组](#WhatIs.Components.ParameterGroups)
+ [ElastiCache 安全](#WhatIs.Components.Security)
+ [ElastiCache 子网组](#WhatIs.Components.SubnetGroups)
+ [ElastiCache 备份](#WhatIs.Components.Snapshots)
+ [ElastiCache 事件](#WhatIs.Components.Events)
## ElastiCache 节点
*节点*是 ElastiCache 部署的最小构建块。一个节点可独立于其他节点存在，也可与其他节点之间有某种关系。
节点是固定大小、与网络连接的安全 RAM 区块。每个节点都运行在您创建集群时选择的引擎和版本的实例。如果需要，您可以将集群中的节点纵向扩展或缩减到不同的实例类型。有关更多信息，请参阅 [缩放 ElastiCache](Scaling.md)。
一个集群中的每个节点都是相同的实例类型且运行相同的缓存引擎。每个缓存节点都有自己的域名服务 (DNS) 名称和端口。支持多种缓存节点类型，每种可有不同的关联内存量。有关受支持的节点实例类型的列表，请参阅[受支持的节点类型](CacheNodes.SupportedTypes.md)。
您可以 pay-as-you-go按需购买节点，您只需为使用节点付费。您也可以相当优惠的小时费率购买预留节点。如果使用率高，则购买预留节点可节省资金。假设您的集群几乎始终在使用中，并且您有时会添加节点来满足使用峰值的需求。在这种情况下，您可以购买大量预留节点以在大多数情况下运行。然后，您可以根据偶尔需要添加节点的时间购买 pay-as-you-go节点。有关预留节点的更多信息，请参阅[预留节点](CacheNodes.Reserved.md)。
有关节点的更多信息，请参阅[在 ElastiCache 中管理节点](CacheNodes.md)。
## ElastiCache 碎片
Valkey 或 Redis OSS *分片*（在 API 和 CLI 中称为*节点组*）是 1 到 6 个相关节点的分组。启用集群模式的 Valkey 或 Redis OSS 集群始终有至少一个分片。
分片是一种数据库分区方法，它将大型数据库分成更小、更快、更易于管理的部分，这些部分称为数据分片。这可以通过在多个独立部分之间分配操作来提高数据库效率。使用分片可以带来许多好处，包括提高性能、可扩展性和成本效益。
Valkey 和 Redis OSS 集群（已启用集群模式）最多可以拥有 500 个分片，并且跨分片对您的数据进行分区。如果引擎为 Valkey 或 Redis OSS 5.0.6 或更高版本，您可以将每个集群的节点或分片限制增至最多 500 个。例如，您可以选择配置一个 500 节点的集群，范围介于 83 个分片（一个主分片和 5 个副本分片）和 500 个分片（一个主分片，无副本分片）之间。确保可提供足够的 IP 地址来满足增长需求。常见的陷阱包括子网组中的子网 CIDR 范围太小，或者子网被其他集群共享和大量使用。有关更多信息，请参阅 [创建子网组](SubnetGroups.Creating.md)。对于低于 5.0.6 的版本，每个集群的限制为 250。
若要请求提高限制，请参阅 [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) 并选择限制类型 **Nodes per cluster per instance type（每个实例类型的每个集群的节点数）**。
*多节点分区*通过指定一个读/写主节点和 1 到 5 个副本节点来实现复制。有关更多信息，请参阅 [使用复制组时的高可用性](Replication.md)。
有关分片的更多信息，请参阅[在 ElastiCache 中使用分片](Shards.md)。
## ElastiCache 集群
*集群*是一个或多个[节点](CacheNodes.md)的逻辑分组。数据在 Memcached 集群的各节点之间进行分区，并在 Valkey 或 Redis OSS 集群（启用集群模式）的各分片之间进行分区。
许多 ElastiCache 操作都是针对集群的：
+ 创建集群
+ 修改集群
+ 为集群拍摄快照（所有版本的 Redis）
+ 删除集群
+ 查看集群中的元素
+ 在集群中添加和删除成本分配标签
有关更多详细信息，请参阅以下相关主题：
+ [在 ElastiCache 中管理集群](Clusters.md) 和 [在 ElastiCache 中管理节点](CacheNodes.md)
有关集群、节点和相关操作的信息。
+ [AWS服务限制：Amazon ElastiCache](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_elasticache)
有关 ElastiCache 限制的信息，例如节点或集群的最大数量。要超出这些限制中的某些限制，您可以使用 [Amazon ElastiCache 缓存节点申请表提出请求](https://aws.amazon.com/contact-us/elasticache-node-limit-request/)。
+ [缓解故障](disaster-recovery-resiliency.md#FaultTolerance)
有关增强 Valkey 或 Redis OSS 集群和复制组的容错能力的信息。
### 典型集群配置
以下是典型的集群配置。
#### Valkey 或 Redis OSS 集群
Valkey 或 Redis OSS 集群（已禁用集群模式）始终只包含一个分片（在 API 和 CLI 中为一个节点组）。一个 Valkey 或 Redis OSS 分片包含 1 到 6 个节点。如果分区中有多个节点，则该分区支持复制。在这种情况下，一个节点是 read/write 主节点，其他节点是只读副本节点。
为了提高容错能力，我们建议在 Valkey 或 Redis OSS 集群中包含至少两个节点，并启用多可用区。有关更多信息，请参阅 [缓解故障](disaster-recovery-resiliency.md#FaultTolerance)。
随着对 Valkey 或 Redis OSS（已禁用集群模式）集群的需求发生变化，您可以纵向扩展或纵向缩减。为此，请将您的集群移到其他节点实例类型。如果您的应用程序属于读取密集型，建议您在集群中添加只读副本。通过执行此操作，您可以将读取分布到更多数量的节点上。
您还可以使用数据分层功能。将访问频率更高的数据存储在内存中，而将访问频率较低的数据存储在磁盘上。使用数据分层的优点是可以减少内存需求。有关更多信息，请参阅 [ElastiCache 中的数据分层](data-tiering.md)。
ElastiCache 支持动态将 Valkey 或 Redis OSS 集群的节点类型更改为更大的节点类型。有关纵向扩展或缩减的信息，请参阅[扩缩 Valkey 或 Redis OSS（已禁用集群模式）集群](scaling-redis-classic.md#Scaling.RedisStandalone)或[扩缩单节点 Valkey 或 Redis OSS（已禁用集群模式）副本节点](Scaling.RedisReplGrps.md)。
#### Memcached 典型集群配置
Memcached 为每个AWS区域的每个客户最多支持 300 个节点，每个集群有 1-60 个节点。您可以跨 Memcached 集群中的节点对数据进行分区。
在运行 Memcached 引擎时，集群可以由 1-60 个节点构成。您可以将数据库分配到多个节点上。应用程序会对每个节点的终端节点进行读写操作。有关更多信息，请参阅[自动发现](AutoDiscovery.md)。
为了提高容错能力，请在集群AWS区域内的各个可用区 (AZs) 中找到 Memcached 节点。这样一来，可最大程度地减小某个可用区内的故障对整个集群和应用程序的影响。有关更多信息，请参阅 [缓解故障](disaster-recovery-resiliency.md#FaultTolerance)。
由于 Memcached 集群需求不断变化的，您可通过添加或删除节点来进行向外扩展或向内扩展，从而跨新数量的节点对数据进行重新分区。对数据进行分区时，建议使用一致性哈希处理。有关一致性哈希处理的更多信息，请参阅[配置您的 ElastiCache 客户端以实现高效的负载平衡 (Memcached)](BestPractices.LoadBalancing.md)。
## ElastiCache 复制
对于 Valkey 和 Redis OSS，您可以通过在一个分片（在 API 和 CLI 中，称为节点组）中对 2 到 6 个节点进行分组来实现复制。在这些节点中，有一个是读取/写入主节点。所有其他节点均为只读副本节点。复制仅适用于 Valkey 和 Redis OSS，不 ElastiCache 适用于 Memcached。 ElastiCache
每个副本节点保留一个主节点中的数据的副本。复制节点使用异步复制机制来与主节点保持同步。应用程序可从集群中的任何节点进行读取，但只能对主节点进行写入。只读副本通过跨多个终端节点分布读取来增强可扩展性。只读副本还通过维护数据的多个副本来增强容错能力。在多个可用区内定位只读副本可进一步增强容错能力。有关容错能力的更多信息，请参阅[缓解故障](disaster-recovery-resiliency.md#FaultTolerance)。
Valkey 或 Redis OSS（已禁用集群模式）集群支持一个分片（在 API 和 CLI 中称为*节点组*）。
从 API 和 CLI 的视角来看，复制使用了不同的术语来维护与之前版本的兼容性，但结果是相同的。下表显示了用于实现复制的 API 和 CLI 术语。
**比较复制：Valkey 或 Redis OSS（已禁用集群模式）与 Valkey 或 Redis OSS（已启用集群模式）--> Valkey 或 Redis OSS 集群（已启用集群模式）与 Valkey 或 Redis OSS 集群（已禁用集群模式）**
下表所示为 Valkey 或 Redis OSS（已禁用集群模式）与 Valkey 或 Redis OSS（已启用集群模式）复制组的功能对比。
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/WhatIs.Components.html)
所有分区（在 API 和 CLI 中称为节点组）和节点必须位于同一AWS区域内。但是，您可以AWS在该区域内的多个可用区中配置单个节点。
只读副本可防止潜在的数据丢失，因为数据是在两个或多个节点（主节点和一个或多个只读副本）上复制的。为获得更高可靠性和更快地恢复，建议您在不同可用区内创建一个或多个只读副本。
您还可以利用全局数据存储。通过使用适用于 Redis OSS 的全球数据存储功能，您可以跨AWS区域进行完全托管、快速、可靠和安全的复制。使用此功能，您可以为创建跨区域只读副本集群， ElastiCache 以实现跨AWS区域的低延迟读取和灾难恢复。有关更多信息，请参阅[使用全球数据存储跨AWS区域复制](Redis-Global-Datastore.md)。
**复制：限制和局限**
+ 节点类型 T1 不支持多可用区。
## ElastiCache 端点
终*端节点*是您的应用程序用于连接到 ElastiCache 节点或集群的唯一地址。
### Valkey 或 Redis OSS（已禁用集群模式）的单节点端点
单节点 Valkey 或 Redis OSS 集群的端点用于连接到用于读取和写入的集群。
### Valkey 或 Redis OSS（已禁用集群模式）的多节点端点
多节点 Valkey 或 Redis OSS（已禁用集群模式）集群包含两种类型的端点。主终端节点始终连接到集群中的主节点，即使主角色中的特定节点发生更改也是如此。使用主终端节点执行对集群的所有写入操作。
使用读取器端点 将在所有只读副本之间均匀地分配指向端点的传入连接。使用单个节点终端节点进行读取操作（在 API/CLI 这些端点中称为读取终端节点）。
### Valkey 或 Redis（已启用集群模式）端点
Valkey 或 Redis OSS 集群（已启用集群模式）有一个单配置端点。通过连接到配置端点，您的应用程序可以查找集群中每个分片的主端点和读取端点。
有关更多信息，请参阅 [查找 ElastiCache 中的缓存连接端点](Endpoints.md)。
### ElastiCache 用于内存缓存终端节点
Memcached 集群中的每个节点都有自己的终端节点。该集群还具有一个称为*配置终端节点* 的终端节点。如果您启用 Auto Discovery 并连接到配置终端节点，则即使是在集群中添加或移除节点后，应用程序仍将自动*获知*每个节点终端节点。有关更多信息，请参阅[自动发现](AutoDiscovery.md)。
有关更多信息，请参阅 [查找 ElastiCache 中的缓存连接端点](Endpoints.md)。
## ElastiCache 参数组
缓存参数组是为受支持的引擎软件管理运行时设置的简单方法。参数用于控制内存使用率、移出策略、项目大小等。 ElastiCache 参数组是可以应用于集群的引擎特定参数的命名集合。通过这样做，您可以确保该集群中的所有节点都以完全相同的方式进行配置。
有关受支持的参数、其默认值以及其中可以修改的参数的列表，请参阅 [DescribeEngineDefaultParameters](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeEngineDefaultParameters.html)（CLI：[describe-engine-default-parameters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-engine-default-parameters.html)）。
有关 ElastiCache 参数组的更多详细信息，请参阅[使用 ElastiCache 参数组配置引擎参数](ParameterGroups.md)。
## ElastiCache 安全
为了增强安全性， ElastiCache 只有在您允许的 Amazon EC2 实例上运行的应用程序才能访问节点。您可以使用安全组控制可以访问您的集群的 Amazon EC2 实例。
默认情况下，所有新 ElastiCache 集群都在亚马逊虚拟私有云 (Amazon VPC) 环境中启动。您可以使用*子网组向在特定子网*上运行的 Amazon EC2 实例授予集群访问权限。
除了限制节点访问外，还 ElastiCache 支持对运行指定版本的节点进行 TLS 和就地加密。 ElastiCache有关更多信息，请参阅下列内容：
+ [Amazon ElastiCache 中的数据安全性](encryption.md)
+ [使用 Valkey 和 Redis OSS AUTH 命令进行身份验证](auth.md)
## ElastiCache 子网组
*子网组*是您可为在 Amazon VPC 环境中运行的集群指定的子网（通常为私有子网）集合。
如果您在 Amazon VPC 中创建集群，则必须指定缓存子网组。ElastiCache 使用该缓存子网组选择一个子网和该子网内的 IP 地址，以便与您的缓存节点关联。
有关 Amazon VPC 环境中缓存子网组使用情况的更多信息，请参阅以下内容：
+ [Amazon VPCs 与 ElastiCache 安全](VPCs.md)
+ [步骤 3：授予对集群的访问权限](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey)
+ [子网和子网组](SubnetGroups.md)
## ElastiCache 备份
*备份*是 Valkey 或 Redis OSS 集群或无服务器缓存的 point-in-time副本，或者是 Memcached 无服务器缓存的副本。备份可用于还原现有集群或为新集群做种。备份包含集群中的所有数据和某些元数据。
根据您集群上运行的 Valkey 或 Redis OSS 版本，备份过程需要不同的预留内存量才能成功。有关更多信息，请参阅下列内容：
+ [快照和还原](backups.md)
+ [如何实施同步和备份](Replication.Redis.Versions.md)
+ [备份基于节点的集群对性能的影响](backups.md#backups-performance)
+ [确保具有用于创建 Valkey 或 Redis OSS 快照的足够内存](BestPractices.BGSAVE.md)
## ElastiCache 事件
当集群上发生重要事件时， ElastiCache 会向特定的 Amazon SNS 主题发送通知。这些事件可能包括诸如添加节点失败、添加节点成功、修改安全组等内容。通过监控关键事件，您可以了解集群的当前状态，并且在许多情况下，您都可用采取相应的纠正措施。
有关 ElastiCache 事件的更多信息，请参阅[Amazon SNS 监控 ElastiCache 事件](ECEvents.md)。
# ElastiCache 术语
2016 年 10 月，亚马逊 ElastiCache 开始支持 Redis OSS 3.2。那时，我们增加了将您的数据分区到最多 500 个分片（在 ElastiCache API 中称为节点组和AWS CLI）的支持。为了与旧版本保持兼容，我们扩展了 API 版本 2015-02-02 的操作，以涵盖新的 Redis OSS 功能。
同时，我们开始在 ElastiCache 控制台中使用术语，该术语用于这项新功能，并且在整个行业中都很常见。这些更改意味着在某些时候，API 和 CLI 中使用的术语可能与控制台中使用的术语不同。以下列表指出了在 API、CLI 与控制台中可能存在差异的术语。
**缓存集群或节点与节点**
如果没有副本节点，则节点和集群之间存在 one-to-one关系。因此， ElastiCache 控制台经常互换使用这些术语。控制台现将统一使用术语*节点*。唯一的例外是 **Create Cluster (创建集群)** 按钮，该按钮用于启动一个流程来创建包含或不包含副本节点的集群。
ElastiCache API AWS CLI继续像过去一样使用这些术语。
**集群与 Valkey 或 Redis OSS 复制组**
现在，控制台对 Redis OSS *集群*使用了 “集群” 一词。 ElastiCache 控制台在以下所有情况中使用术语“集群”：
+ 集群是单节点 Valkey 或 Redis OSS 集群。
+ 当集群是支持单分片（在 API 和 CLI 中称为*节点组*）中复制的 Valkey 或 Redis OSS（已禁用集群模式）集群时。
+ 当集群是支持 1-90 个分片或最多 500 个分片（须提出限制提高请求）中复制的 Valkey 或 Redis OSS（已启用集群模式）集群时。若要请求提高限制，请参阅 [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) 并选择限制类型 **Nodes per cluster per instance type（每个实例类型的每个集群的节点数）**。
有关 Valkey 或 Redidis OSS 复制组的更多信息，请参阅[使用复制组时的高可用性](Replication.md)。
下图从控制台的角度说明了 Redis OSS 集群的各种拓扑。 ElastiCache
![\[图片： ElastiCache 集群（控制台视图）\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-Clusters-ConsoleView.png)
ElastiCache API 和AWS CLI操作仍然将 Redis OSS 集群 ElastiCache 的单节点与多节点 Valkey 或 Redis OSS 复制组区分开来。下图从 ElastiCache API 和AWS CLI角度说明了 Redis OSS 的各种 ElastiCache 拓扑。
![\[图片： ElastiCache 适用于 Redis OSS 集群和 Valkey 或 Redis OSS 复制组（API 和 CLI 视图）\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-Clusters-APIView.png)
**Valkey 或 Redidis OSS 复制组与全局数据存储**
全局数据存储是可跨区域相互复制的一个或多个集群的集合，而 Valkey 或 Redis OSS 复制组可复制具有多个分片的集群（已启用集群模式）中的数据。全局数据存储包含以下项：
+ **主（主动）集群** – 主集群接受复制到全局数据存储中的所有集群的写入。主集群也接受读取请求。
+ **辅助（被动）集群** – 辅助集群仅接受读取请求并从主集群复制数据更新。辅助群集必须与主群集位于不同的AWS区域。
有关全局数据存储的信息，请参阅 [使用全球数据存储跨AWS区域复制](Redis-Global-Datastore.md)。
# 教程：如何创建基于节点的集群 ElastiCache
以下是如何为 Valkey、Memcached 和 Redis OSS 创建基于节点的 ElastiCache 集群。
**Topics**
+ [为 Valkey 创建基于节点的 ElastiCache 集群](SubnetGroups.designing-cluster-pre.valkey.md)
+ [为 Redis OSS 创建基于节点的 ElastiCache 集群](SubnetGroups.designing-cluster-pre.redis.md)
# 为 Valkey 创建基于节点的 ElastiCache 集群
以下是为 Valkey 创建基于节点的 ElastiCache 集群必须执行的一次性操作。
## 步骤 1：创建子网组
在创建 ElastiCache (Valkey) 集群之前，首先要创建一个子网组。*缓存子网组*是您要为 VPC 中的集群指定的子网集合。当您启动 VPC 中的某个集群时，您需要选择一个缓存子网组。然后 ElastiCache 使用该缓存子网组将该子网内的 IP 地址分配给群集中的每个缓存节点。
当您创建新的子网组时，请记下可用 IP 地址的数量。如果子网拥有的空闲 IP 地址很少，则您可以向集群中添加的额外节点数可能会受限制。要解决此问题，您可以对某一子网组分配一个或多个子网，这样集群的可用区中便会有充足数量的 IP 地址。之后，便可向您的集群中添加更多节点。
有关设置的更多信息， ElastiCache 请参阅[设置 ElastiCache](set-up.md)。
以下过程演示如何创建名为 `mysubnetgroup` 的子网组（控制台）和AWS CLI。
### 创建子网组（控制台）
以下过程介绍如何创建子网组（控制台）。
**创建子网组（控制台）**
1. 登录到AWS管理控制台，然后在上打开 ElastiCache 控制台[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 在导航列表中，选择 ** Subnet Groups**。
1. 选择 **Create Subnet Group**。
1. 在 **Create Subnet Group（创建子网组）**向导中，执行以下操作。根据需要完成所有设置后，选择 **Yes, Create**。
1. 在 **Name** 框中，为子网组键入名称。
1. 在 **Description** 框中，为子网组键入描述。
1. 在 **VPC ID** 框中，选择您创建的 Amazon VPC。
1. 在**可用区**和**子网 ID** 列表中，选择您的私有子网的可用区或 [将 Local Zones 与 ElastiCache 结合使用](Local_zones.md) 和 ID，然后选择**添加**。
![\[图像：创建子网 VPC 屏幕\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/vpc-03.png)
1. 在出现的确认信息中，选择 **Close**。
您的新子网组显示在 ElastiCache 控制台的**子网组**列表中。您可以在窗口底部选择子网组以查看详细信息，例如与此组关联的所有子网。
### 创建子网组 (AWS CLI)
在命令提示符处，使用命令 `create-cache-subnet-group` 创建子网组。
对于 Linux、macOS 或 Unix：
```
aws elasticache create-cache-subnet-group \
--cache-subnet-group-name mysubnetgroup \
--cache-subnet-group-description "Testing" \
--subnet-ids subnet-53df9c3a
```
对于 Windows：
```
aws elasticache create-cache-subnet-group ^
--cache-subnet-group-name mysubnetgroup ^
--cache-subnet-group-description "Testing" ^
--subnet-ids subnet-53df9c3a
```
该命令应该生成类似于下述信息的输出：
```
{
"CacheSubnetGroup": {
"VpcId": "vpc-37c3cd17",
"CacheSubnetGroupDescription": "Testing",
"Subnets": [
{
"SubnetIdentifier": "subnet-53df9c3a",
"SubnetAvailabilityZone": {
"Name": "us-west-2a"
}
}
],
"CacheSubnetGroupName": "mysubnetgroup"
}
}
```
有关更多信息，请参阅AWS CLI主题[create-cache-subnet-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-subnet-group.html)。
## 步骤 2：创建集群
在创建用于生产使用的集群之前，您显然需要考虑如何配置集群以满足您的业务需求。这些问题在 [准备在 ElastiCache 中创建集群](Clusters.Prepare.md) 部分中解决。就本入门练习而言，您将创建一个禁用集群模式的集群，并且您可以在其适用时接受默认配置值。
您所创建的集群将是活动的，不会在沙盒中运行。在您删除实例之前，您需要为其支付标准 ElastiCache 使用费。如果您一鼓作气完成此处描述的练习并在使用完毕后删除集群，则产生的全部费用将非常少（通常不到一美元）。有关 ElastiCache 使用费率的更多信息，请参阅 [Amazon ElastiCache](https://aws.amazon.com/elasticache/)。
在虚拟私有云（VPC）中基于 Amazon VPC 服务启动集群。
### 创建 Valkey（已禁用集群模式）集群（控制台）
**使用控制台创建 Valkey（已禁用集群模式）集群 ElastiCache**
1. 登录AWS 管理控制台并打开 Amazon ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 从右上角的列表中，选择要在其中启动此集群的AWS区域。
1. 从导航窗格中，选择 **Get started**（入门）。
1. 选择 **Create VPC**（创建 VPC）并按照[创建虚拟私有云（VPC）](VPCs.CreatingVPC.md)中的步骤操作。
1. 在 ElastiCache 控制面板页面上，选择 **Valkey 缓存或 Redis OSS 缓****存**，然后选择**创建 Valkey 缓存或创**建 Redis** OSS 缓存**。
1. 在 **Cluster settings**（集群设置）下，执行以下操作：
1. 选择 **Configure and create a new cluster**（配置和创建新集群）。
1. 对于 **Cluster mode**（集群模式），选择 **Disabled**（已禁用）。
1. 对于 **Cluster info**（集群信息），为 **Name**（名称）输入一个值。
1. （可选）为 **Description**（描述）输入一个值。
1. 在 **Location**（位置）下：
------
#### [ AWS Cloud ]
1. 对于 **AWS Cloud**，我们建议您接受 **Multi-AZ**（多可用区）和 **Auto-failover**（自动失效转移）的默认设置。有关更多信息，请参阅使用[多可用区 ElastiCache 最大限度地缩短 Redis OSS 的停机时间](AutoFailover.md)。
1. 在 **Cluster settings**（集群设置）下
1. 对于 **Engine version**（引擎版本），选择一个可用的引擎版本。
1. 对于 **Port**（端口），使用默认端口 6379。如果您出于某个原因需要使用其他端口，请输入相应的端口号。
1. 对于**参数组**，选择一个参数组或创建一个新参数组。参数组控制集群的运行时参数。有关参数组的更多信息，请参阅[Valkey 和 Redis OSS 参数](ParameterGroups.Engine.md#ParameterGroups.Redis) 和[创建 ElastiCache 参数组](ParameterGroups.Creating.md)。
**注意**
当您选择要设置引擎配置值的参数组时，该参数组将应用于全局数据存储中的所有集群。在 **Parameter Groups（参数组）**页面上，是/否 **Global（全局）**属性指示参数组是否属于全局数据存储。
1. 对于 **Node type（节点类型）**，请选择向下箭头（![\[Downward-pointing triangle icon, typically used to indicate a dropdown menu.\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-DnArrow.png)）。在 **Change node type（更改节点类型）**对话框中，为所需节点类型选择 **Instance family（实例系列）**值。接着选择要用于此集群的节点类型，然后选择**保存**。
有关更多信息，请参阅 [选择节点大小](CacheNodes.SelectSize.md)。
如果您选择 r6gd 节点类型，则系统会自动启用数据分层。有关更多信息，请参阅 [ElastiCache 中的数据分层](data-tiering.md)。
1. 对于 **Number of replicas**（副本数），选择所需的只读副本数。如果您启用多可用区，则该数字必须介于 1-5 之间。
1. 在 **Connectivity**（连接）下
1. 对于 **Network type**（网络类型），选择此集群将支持的 IP 版本。
1. 对于**子网组**，请选择要应用于此集群的子网。 ElastiCache 使用该子网组选择子网和该子网内的 IP 地址以与您的节点关联。 ElastiCache 群集需要一个双堆栈子网 IPv4 并分配给它们 IPv6 的地址才能在双堆栈模式下运行，并且需要一个 IPv6仅限子网才能以-only模式运行。 IPv6
创建新的子网组时，输入其所属的 **VPC ID**。
有关更多信息，请参阅:
+ [在中选择网络类型 ElastiCache](network-type.md).
+ [在您的 VPC 中创建子网](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet)。
如果您是 [将 Local Zones 与 ElastiCache 结合使用](Local_zones.md)，则必须创建或选择位于本地区域中的子网。
有关更多信息，请参阅 [子网和子网组](SubnetGroups.md)。
1. 对于 **Availability zone placements**（可用区位置），您有两种选择：
+ **无偏好** — ElastiCache 选择可用区。
+ **Specify availability zones（指定可用区）**– 您为各集群指定可用区。
如果您选择指定可用区，则需从列表中为各分片中的每个集群选择可用区。
有关更多信息，请参阅 [为 ElastiCache 选择区域和可用区](RegionsAndAZs.md)。
1. 选择 **Next**（下一步）
1. 在**高级 Valkey 或 Redis OSS 设置**下
1. 对于 **Security**（安全）：
1. 要加密您的数据，您有以下选项：
+ **Encryption at rest（静态加密）**– 对磁盘上存储的数据启用加密。有关更多信息，请参阅[静态加密](at-rest-encryption.md)。
**注意**
您可以选择提供不同的加密密钥，方法是选择 “**客户托管AWS KMS 密钥**” 并选择密钥。有关更多信息，请参阅[使用AWS KMS 客户自主管理型密钥](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security)。
+ **Encryption in-transit（传输中加密）**– 对传输中数据启用加密。有关更多信息，请参阅[传输中加密](in-transit-encryption.md)。对于 Valkey 和 Redis OSS 6.0 及以上版本，如果启用了传输中加密，则系统会提示您指定以下**访问控制**选项中的一个：
+ **No Access Control（无访问控制）**– 此选项为默认设置。这表示对用户访问集群的权限没有任何限制。
+ **User Group Access Control List（用户组访问控制列表）**– 选择具有集群访问权限的已定义用户组。有关更多信息，请参阅 [使用控制台和 CLI 管理用户组](Clusters.RBAC.md#User-Groups)。
+ **AUTH 默认用户** – Redis OSS 服务器的身份验证机制。有关更多信息，请参阅 [AUTH](auth.md)。
+ **AUTH** – Redis OSS 服务器的身份验证机制。有关更多信息，请参阅 [AUTH](auth.md)。
**注意**
对于 Valkey 和 Redis OSS 3.2.6 以上的版本（版本 3.2.10 除外），只能选择 Redis OSS AUTH。
1. 对于**安全组**，选择要用于该集群的安全组。*安全组* 充当防火墙来控制对集群的网络访问。您可以为 VPC 使用默认安全组或创建新安全组。
有关安全组的更多信息，请参阅 *Amazon VPC 用户指南*中的[您的 VPC 的安全组](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)。
1. 如果需要定期计划自动备份，请选择**启用自动备份**，然后输入每个自动备份在被自动删除前保留的天数。如果您不希望定期计划自动备份，请清除 **Enable automatic backups** 复选框。不论是哪种情况，您始终可以选择创建手动备份。
有关 Redis OSS 备份和还原的更多信息，请参阅[快照和还原](backups.md)。
1. （可选）指定维护时段。*维护时段* 是每周中 ElastiCache 为您的集群计划系统维护的时间，通常以小时为时间长度。您可以允许 ElastiCache 选择维护时段的日期和时间（*No preference (无首选项)*），或者自行选择日期、时间和持续时间（*Specify maintenance window (指定维护时段)*）。如果您从列表中选择了*指定维护时段*，请为您的维护时段选择*开始日期*、*开始时间*和*持续时间*（以小时为单位）。所有时间均为 UCT 时间。
有关更多信息，请参阅 [管理 ElastiCache 集群维护](maintenance-window.md)。
1. （可选）对于 **Logs（日志）**：
+ 在 **Log format（日志格式）**下，选择 **Text（文本）**或 **JSON**。
+ 在 “**目标类型**” 下，选择 “**CloudWatch 日志**” 或 “**Kinesis Fire** hose”。
+ 在 “**日志目标**” 下，选择 “**新建**” 并输入您的 CloudWatch 日志日志组名称或 Firehose 直播名称，或者选择 **“选择现有”**，然后选择您的 CloudWatch 日志日志组名称或 Firehose 直播名称，
1. 对于**标签**，为了帮助您管理集群和其他 ElastiCache 资源，您可以以标签的形式为每个资源分配自己的元数据。有关更多信息，请参阅 [为资源添加 ElastiCache 标签](Tagging-Resources.md)。
1. 选择 **Next**（下一步）。
1. 查看您的所有输入和选择，然后进行任意所需的更正。当您准备好后，选择 **Create**（创建）。
------
#### [ On premises ]
1. 对于 **On premises**（本地），我们建议您保留 **Auto-failover**（自动失效转移）为启用状态。有关更多信息，请参阅使用多可用[区 ElastiCache 最大限度地缩短 Redis OSS 的停机时间](AutoFailover.md)
1. 要完成集群创建，请按照[使用 Outposts](ElastiCache-Outposts.md) 中的步骤操作。
------
一旦您的集群状态变为*可用*，您就可以授予 Amazon 对其的 EC2 访问权限、连接该集群并开始使用它。有关更多信息，请参阅[步骤 3：授予对集群的访问权限](#GettingStarted.AuthorizeAccess.valkey)和[步骤 4：连接到集群的节点](#GettingStarted.ConnectToCacheNode.valkey)。
**重要**
您的集群变为可用状态后，您便需要为集群处于活动状态的每个小时或分钟支付费用（即使您并未主动使用集群）。要停止此集群产生的费用，您必须将其删除。请参阅[删除中的集群 ElastiCache](Clusters.Delete.md)。
要在启用集群模式的情况下工作，请参阅以下主题：
+ 要使用控制台，请参阅[创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster)。
+ 要使用AWS CLI，请参阅[创建 Valkey 或 Redis OSS（已启用集群模式）集群（AWS CLI）](Clusters.Create.md#Clusters.Create.CLI.RedisCluster)。
## 步骤 3：授予对集群的访问权限
本节假设您熟悉启动和连接 Amazon EC2 实例。有关更多信息，请参阅 *[Amazon EC2 入门指南](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/)*。
所有 ElastiCache 集群均设计为可从 Amazon EC2 实例进行访问。最常见的情况是从同一个亚马逊虚拟私有云 (Amazon VPC) 中的亚马逊 EC2 实例访问 ElastiCache 集群，本练习就是这种情况。
原定设置情况下，对您的集群的网络访问仅限于用于创建集群的账户。必须先授权该 EC2 实例访问集群，然后才能从 EC2 实例连接到集群。
最常见的用例是部署在 EC2 实例上的应用程序需要连接到同一 VPC 中的集群。管理同一 VPC 中 EC2 实例和集群之间访问权限的最简单方法是执行以下操作：
1. 为集群创建 VPC 安全组。此安全组可用于限制对集群实例的访问权限。例如，可为此安全组创建自定义规则，允许使用您创建集群时分配给该集群的端口以及将用来访问集群的 IP 地址进行 TCP 访问。
Valkey 或 Redis OSS 集群和复制组的默认端口为 `6379`。
**重要**
亚马逊 ElastiCache 安全组仅适用于*未*在亚马逊虚拟私有云环境 (VPC) 中运行的集群。如果您正在 Amazon Virtual Private Cloud 中运行，**安全组**将在控制台导航窗格中将不可用。
如果您在 Amazon VPC 中运行 ElastiCache 节点，则可以使用不同于安全组的 Amazon VPC 安全组来控制对集群的 ElastiCache 访问权限。有关在 Amazon VPC ElastiCache 中使用的更多信息，请参阅 [Amazon VPCs 与 ElastiCache 安全](VPCs.md)
1. 为您的 EC2 实例（Web 和应用程序服务器）创建 VPC 安全组。如果需要，此安全组可以允许通过 VPC 的路由表从 Internet 访问 EC2 实例。例如，您可以在此安全组上设置规则，允许 TCP 通过端口 22 访问 EC2 实例。
1. 在集群的安全组中创建自定义规则，允许来自您为 EC2 实例创建的安全组的连接。这将允许安全组的任何成员均可访问集群。
**注意**
如果您计划使用 [Local Zones](Local_zones.md)，请确保已将其启用。当您在该本地区域中创建子网组时，您的 VPC 也会扩展到该本地区域，并且您的 VPC 会将该子网视为任何其他可用区中的任何子网。所有相关网关和路由表都将自动调整。
**在 VPC 安全组中创建允许从另一安全组连接的规则**
1. 登录AWS管理控制台并在 [https://console.aws.amazon.com/](https://console.aws.amazon.com/vpc)vpc 上打开 Amazon VPC 控制台。
1. 在导航窗格中，选择**安全组**。
1. 选择或创建一个要用于集群实例的安全组。在**入站规则**下，选择**编辑入站规则**，然后选择**添加规则**。此安全组将允许访问其他安全组的成员。
1. 从 **Type** 中选择 **Custom TCP Rule**。
1. 对于 **Port Range**，指定在创建集群时使用的端口。
Valkey 或 Redis OSS 集群和复制组的默认端口为 `6379`。
1. 在 **Source** 框中，开始键入安全组的 ID。从列表中选择您将用于 Amazon EC2 实例的安全组。
1. 完成后选择 **Save**。
![\[\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/VPC-Rules.png)
启用访问后，您现在就可以连接到节点，如下一部分中所述。
有关从其他 Amazon VPC、不同AWS区域甚至企业网络访问您的ElastiCache 集群的信息，请参阅以下内容：
+ [用于访问 Amazon VPC 中的 ElastiCache 缓存的访问模式](elasticache-vpc-accessing.md)
+ [从外部访问 ElastiCache 资源AWS](accessing-elasticache.md#access-from-outside-aws)
## 步骤 4：连接到集群的节点
在继续之前，请完成[步骤 3：授予对集群的访问权限](#GettingStarted.AuthorizeAccess.valkey)。
本节假设您已经创建了一个 Amazon EC2 实例并且可以连接到该实例。有关如何执行此操作的说明，请参阅《[Amazon EC2 入门指南》](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/)。
只有在您授权后，Amazon EC2 实例才能连接到集群节点。
### 查找您的节点端点
当您的集群处于*可用*状态并且您已获得访问权限时，您可以登录 Amazon EC2 实例并连接到该集群。为此，您必须先确定端点。
#### 查找 Valkey（已禁用集群模式）集群的端点（控制台）
如果 Valkey（已禁用集群模式）集群只有一个节点，则使用该节点的端点进行读取和写入操作。如果该集群具有多个节点，则有三种类型的端点，即*主端点*、*读取器端点*和*节点端点*。
主端点是一个 DNS 名称，始终解析为集群中的主节点。主端点不受集群更改的影响，如将只读副本提升为主角色。对于写入活动，我们建议您的应用程序连接到主端点。
读取器终端节点将在 ElastiCache 集群中的所有只读副本之间均匀分配到该终端节点的传入连接。应用程序何时创建连接或应用程序如何（重复）使用连接等附加因素将决定流量分配。读取器端点会在添加或删除副本时实时跟踪集群更改。您可以将 ElastiCache 集群的多个只读副本放在不同的AWS可用区 (AZ) 中，以确保读取器终端节点的高可用性。
**注意**
读取器端点不是负载均衡器。它是一个 DNS 记录，将以循环方式解析为副本节点之一的 IP 地址。
对于读取活动，应用程序还可以连接到集群中的任何节点。与主端点不同，节点端点会解析为特定端点。如果您在您的集群中进行更改（例如添加或删除副本），则必须在您的应用程序中更新节点端点。
**查找 Valkey（已禁用集群模式）集群的端点**
1. 登录AWS 管理控制台并打开 ElastiCache 控制台，网址为[ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 从导航窗格中，选择 **Valkey 缓存**或 **Redis OSS 缓存**。
集群屏幕将显示一个列表，其中包含任何现有 Valkey 或 Redis OSS 无服务器缓存、Valkey（已禁用集群模式）和 Valkey（已启用集群模式）集群。选择在 [创建 Valkey（已禁用集群模式）集群（控制台）](#Clusters.Create.CON.valkey-gs) 部分中创建的集群。
1. 要查找集群的主 and/or 读取器终端节点，请选择集群的名称（不是单选按钮）。
![\[图片：Valkey（已禁用集群模式）集群的主端点\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)
*Valkey（已禁用集群模式）集群的主端点和读取器端点*
如果该集群只有一个节点，则没有主端点，您可以继续下一步。
1. 如果 Valkey（已禁用集群模式）集群有副本节点，您可以通过选择此集群的名称、然后选择**节点**选项卡来找到集群副本的节点端点。
此时会显示节点屏幕，其中列出了集群中的每个节点（主节点和副本节点）及其端点。
![\[图片：Valkey（已禁用集群模式）集群的节点端点\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)
*Valkey（已禁用集群模式）集群的节点端点*
1. 将端点复制到剪贴板：
1. 逐一找到要复制的端点。
1. 直接选择端点前面的复制图标。
端点现已复制到剪贴板。有关使用端点连接到节点的信息，请参阅 [连接到节点](nodes-connecting.md)。
Valkey（已禁用集群模式）主端点类似以下内容。根据是否已启用传输中加密而有所不同。
**未启用传输中加密**
```
clusterName.xxxxxx.nodeId.regionAndAz.cache.amazonaws.com:port
redis-01.7abc2d.0001.usw2.cache.amazonaws.com:6379
```
**已启用传输中加密**
```
master.clusterName.xxxxxx.regionAndAz.cache.amazonaws.com:port
master.ncit.ameaqx.use1.cache.amazonaws.com:6379
```
为进一步了解如何查找您的端点，请参阅您正在运行的引擎和集群类型的相关主题。
+ [查找 ElastiCache 中的缓存连接端点](Endpoints.md)
+ [查找 Valkey 或 Redis OSS（已启用集群模式）集群的端点（控制台）](Endpoints.md#Endpoints.Find.RedisCluster) – 您需要集群的配置端点。
+ [查找端点（AWS CLI）](Endpoints.md#Endpoints.Find.CLI)
+ [查找端点（ElastiCache API）](Endpoints.md#Endpoints.Find.API)
### 连接到 Valkey 或 Redis OSS 集群或复制组（Linux）
现在您已经有了所需的终端节点，可以登录 EC2 实例并连接到集群或复制组。在以下示例中，您使用 *valkey-cli* 实用工具连接到集群。最新版本的 valkey-cli 还支持连接 encryption/authentication 已启 SSL/TLS 用的集群。
以下示例使用运行亚马逊 Linux 和亚马逊 Linux 2 的亚马逊 EC2 实例。有关使用其他 Linux 发行版安装和编译 valkey-cli 的详细信息，请参阅特定操作系统的文档。
**注意**
此过程包括使用仅供计划外使用的 valkey-cli 实用工具测试连接。有关受支持 Valkey 和 Redis OSS 客户端的列表，请参阅 [Valkey 文档](https://valkey.io/)。有关与 with AWS SDKs 一起使用的示例 ElastiCache，请参见[教程：Python 和 ElastiCache 入门](ElastiCache-Getting-Started-Tutorials.md)。
#### 连接到已禁用集群模式的未加密的集群
1. 运行以下命令以连接到集群，并将*primary-endpoint*和*port number*替换为集群的终端节点和您的端口号。（Valkey 或 Redis OSS 的默认端口为 6379。）
```
src/valkey-cli -h primary-endpoint -p port number
```
Valkey 或 Redis OSS 命令提示符的结果类似于以下内容：
```
primary-endpoint:port number
```
1. 现在您就可以运行 Valkey 或 Redis OSS 命令了。
```
set x Hello
OK
get x
"Hello"
```
#### 连接到已启用集群模式的未加密集群
1. 运行以下命令以连接到集群，并将*configuration-endpoint*和*port number*替换为集群的终端节点和您的端口号。（Valkey 或 Redis OSS 的默认端口为 6379。）
```
src/valkey-cli -h configuration-endpoint -c -p port number
```
**注意**
在上述命令中，选项 -c 可遵循 [-ASK 和 -MOVED 重新导向](https://valkey.io/topics/cluster-spec)启用集群模式。
Valkey 或 Redis OSS 命令提示符的结果类似于以下内容：
```
configuration-endpoint:port number
```
1. 现在您就可以运行 Valkey 或 Redis OSS 命令了。请注意，重新导向发生是因为您使用 -c 选项启用了它。如果未启用重新导向，则命令将返回 MOVED 错误。有关 MOVED 错误的更多信息，请参阅 [Redis OSS 集群规范](https://valkey.io/topics/cluster-spec)。
```
set x Hi
-> Redirected to slot [16287] located at 172.31.28.122:6379
OK
set y Hello
OK
get y
"Hello"
set z Bye
-> Redirected to slot [8157] located at 172.31.9.201:6379
OK
get z
"Bye"
get x
-> Redirected to slot [16287] located at 172.31.28.122:6379
"Hi"
```
#### 连接到 Encryption/Authentication 已启用的集群
默认情况下，valkey-cli 在连接到 Valkey 或 Redis OSS 时使用未加密的 TCP 连接。该选项 SSL/TLS 在编译 valkey-cli 时`BUILD_TLS=yes`启用，如上一节所示。[下载并设置命令行访问权限](set-up.md#Download-and-install-cli)启用 AUTH 是可选的。但是，您必须启用传输过程中的加密才能启用 AUTH。有关 ElastiCache 加密和身份验证的更多详细信息，请参阅[ElastiCache 传输中加密 (TLS)](in-transit-encryption.md)。
**注意**
您可以通过 valkey-cli 使用选项 `--tls` 连接到已启用和已禁用集群模式的加密集群。如果集群设置了 AUTH 令牌，则可以使用选项 `-a` 以提供 AUTH 密码。
在以下示例中，请务必将*cluster-endpoint*和*port number*替换为集群的终端节点和您的端口号。（Valkey 或 Redis OSS 的默认端口为 6379。）
**连接到已禁用集群模式的加密群集**
以下示例连接到已启用加密和身份验证的集群：
```
src/valkey-cli -h cluster-endpoint --tls -a your-password -p port number
```
以下示例连接到仅启用加密的集群：
```
src/valkey-cli -h cluster-endpoint --tls -p port number
```
**连接到已启用集群模式的加密群集**
以下示例连接到已启用加密和身份验证的集群：
```
src/valkey-cli -c -h cluster-endpoint --tls -a your-password -p port number
```
以下示例连接到仅启用加密的集群：
```
src/valkey-cli -c -h cluster-endpoint --tls -p port number
```
连接到集群后，您可以为未加密集群运行上述示例中的 Valkey 或 Redis OSS 命令。
#### valkey-cli 替代方案
如果集群未启用集群模式，并且您需要与集群建立连接以进行短期测试（但不经过 valkey-cli 编译），则可以使用 telnet 或 openssl。在以下示例命令中，请务必将*cluster-endpoint*和*port number*替换为集群的终端节点和您的端口号。（Valkey 或 Redis OSS 的默认端口为 6379。）
以下示例连接到启用了加密 and/or 身份验证的集群模式已禁用的集群：
```
openssl s_client -connect cluster-endpoint:port number
```
如果集群已设置密码，请先连接到集群。连接后，使用以下命令对集群进行身份验证，然后按 `Enter` 键。在以下示例中，*your-password*替换为您的集群的密码。
```
Auth your-password
```
以下示例连接到未启用加密或身份验证的已禁用集群模式的集群：
```
telnet cluster-endpoint port number
```
### 连接到 Valkey 或 Redis OSS 集群或复制组（Windows）
要使用 Valkey CLI 或 Redis OSS CLI 从 EC2 Windows 实例连接 Valkey 或 Redis OSS 集群，你必须*下载* valkey-cli 包*并*使用 valkey-cli.exe 从 Windows 实例连接 Valkey 或 Redis OSS 集群。 EC2
在以下示例中，您使用 *valkey-cli* 实用工具连接到未启用加密的运行 Valkey 或 Redis OSS 的集群。有关 Valkey 或 Redis OSS 和可用命令的更多信息，请参阅 Valkey 网站上的 [Valkey 和 Redis OSS 命令](http://valkey.io/commands)。
**使用 *valkey-cli* 连接未启用加密的 Valkey 或 Redis OSS 集群**
1. 使用您选择的连接实用程序连接到您的 Amazon EC2 实例。有关如何连接亚马逊 EC2 实例的说明，请参阅《[亚马逊 EC2 入门指南》](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/)。
1. 将链接复制并粘贴到互联网浏览器[https://github.com/microsoftarchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.zip](https://github.com/microsoftarchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.zip)中，从可用版本中下载 Valkey 客户端的 zip 文件，网址为 GitHub [https://github.com/microsoftarchive/redis/releases/tag/win-3.0.504](https://github.com/microsoftarchive/redis/releases/tag/win-3.0.504)
将 zip 文件提取到您指定的文件夹/路径。
打开命令提示符并更改为 Valkey 目录，然后运行命令 `c:\Valkey>valkey-cli -h Redis_Cluster_Endpoint -p 6379`。
例如：
```
c:\Valkey>valkey-cli -h cmd.xxxxxxx.ng.0001.usw2.cache.amazonaws.com -p 6379
```
1. 运行 Valkey 或 Redis OSS 命令。
您现已连接至集群并且可以按以下方式运行 Valkey 或 Redis OSS 命令。
```
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
get b // Get value for key "b" results in miss
(nil)
set b "Good-bye" EX 5 // Set key "b" with a string value and a 5 second expiration
"Good-bye"
get b // Get value for key "b"
"Good-bye"
// wait >= 5 seconds
get b
(nil) // key has expired, nothing returned
quit // Exit from valkey-cli
```
## 接下来该做什么？
现在，您已经尝试了入门练习，可以浏览以下各节以了解有关可用工具 ElastiCache 的更多信息：
+ [入门AWS](https://aws.amazon.com/getting-started/)
+ [用于 Amazon Web Services 的工具](https://aws.amazon.com/tools/)
+ [AWS命令行界面](https://aws.amazon.com/cli/)
+ [亚马逊 ElastiCache API 参考](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/Welcome.html)
完成入门练习后，您可以阅读以下章节以了解有关 ElastiCache 管理的更多信息：
+ [选择节点大小](CacheNodes.SelectSize.md)
您希望缓存足够大以容纳要进行缓存的所有数据。同时，您不希望为所需缓存之外的缓存付费。使用本主题可帮助您选择最佳节点大小。
+ [ElastiCache 最佳实践和缓存策略](BestPractices.md)
确定并解决会影响集群效率的问题。
# 为 Redis OSS 创建基于节点的 ElastiCache 集群
为了为 Redis OSS 创建基于节点的 ElastiCache 集群，您必须执行以下一次性操作。
有关设置的更多信息， ElastiCache 请参阅[设置 ElastiCache](set-up.md)。
**Topics**
+ [步骤 1：创建子网组](#SubnetGroups.Creating-gs.redis)
+ [步骤 2：创建集群](#GettingStarted.CreateCluster.redis)
+ [步骤 3：授予对集群的访问权限](#GettingStarted.AuthorizeAccess.redis)
+ [步骤 4：连接到集群节点](#GettingStarted.ConnectToCacheNode.redis)
## 步骤 1：创建子网组
在您创建集群之前，请先创建子网组。*缓存子网组*是您要为 VPC 中的集群指定的子网集合。当您启动 VPC 中的某个集群时，您需要选择一个缓存子网组。然后 ElastiCache 使用该缓存子网组将该子网内的 IP 地址分配给群集中的每个缓存节点。
当您创建新的子网组时，请记下可用 IP 地址的数量。如果子网拥有的空闲 IP 地址很少，则您可以向集群中添加的额外节点数可能会受限制。要解决此问题，您可以对某一子网组分配一个或多个子网，这样集群的可用区中便会有充足数量的 IP 地址。之后，便可向您的集群中添加更多节点。
以下过程演示如何创建名为 `mysubnetgroup` 的子网组（控制台）和AWS CLI。
### 创建子网组（控制台）
以下过程介绍如何创建子网组（控制台）。
**创建子网组（控制台）**
1. 登录到AWS管理控制台，然后在上打开 ElastiCache 控制台[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 在导航列表中，选择 ** Subnet Groups**。
1. 选择 **Create Subnet Group**。
1. 在 **Create Subnet Group（创建子网组）**向导中，执行以下操作。根据需要完成所有设置后，选择 **Yes, Create**。
1. 在 **Name** 框中，为子网组键入名称。
1. 在 **Description** 框中，为子网组键入描述。
1. 在 **VPC ID** 框中，选择您创建的 Amazon VPC。
1. 在 **Availability Zone（可用区）**和 **Subnet ID（子网 ID）**列表中，选择可用区或 [Local Zone（本地区域）](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/Local_zones.html)和您的私有子网 ID，然后选择 **Add（添加）**。
![\[图像：创建子网 VPC 屏幕\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/vpc-03.png)
1. 在出现的确认信息中，选择 **Close**。
您的新子网组显示在 ElastiCache 控制台的**子网组**列表中。您可以在窗口底部选择子网组以查看详细信息，例如与此组关联的所有子网。
### 创建子网组 (AWS CLI)
在命令提示符处，使用命令 `create-cache-subnet-group` 创建子网组。
对于 Linux、macOS 或 Unix：
```
aws elasticache create-cache-subnet-group \
--cache-subnet-group-name mysubnetgroup \
--cache-subnet-group-description "Testing" \
--subnet-ids subnet-53df9c3a
```
对于 Windows：
```
aws elasticache create-cache-subnet-group ^
--cache-subnet-group-name mysubnetgroup ^
--cache-subnet-group-description "Testing" ^
--subnet-ids subnet-53df9c3a
```
该命令应该生成类似于下述信息的输出：
```
{
"CacheSubnetGroup": {
"VpcId": "vpc-37c3cd17",
"CacheSubnetGroupDescription": "Testing",
"Subnets": [
{
"SubnetIdentifier": "subnet-53df9c3a",
"SubnetAvailabilityZone": {
"Name": "us-west-2a"
}
}
],
"CacheSubnetGroupName": "mysubnetgroup"
}
}
```
有关更多信息，请参阅AWS CLI主题[create-cache-subnet-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-subnet-group.html)。
## 步骤 2：创建集群
在创建用于生产使用的集群之前，您显然需要考虑如何配置集群以满足您的业务需求。这些问题在 [准备在 ElastiCache 中创建集群](Clusters.Prepare.md) 部分中解决。就本入门练习而言，您将创建一个禁用集群模式的集群，并且您可以在其适用时接受默认配置值。
您所创建的集群将是活动的，不会在沙盒中运行。在您删除实例之前，您需要为其支付标准 ElastiCache 使用费。如果您一鼓作气完成此处描述的练习并在使用完毕后删除集群，则产生的全部费用将非常少（通常不到一美元）。有关 ElastiCache 使用费率的更多信息，请参阅 [Amazon ElastiCache](https://aws.amazon.com/elasticache/)。
在虚拟私有云（VPC）中基于 Amazon VPC 服务启动集群。
### 创建 Redis OSS（已禁用集群模式）集群（控制台）
**使用控制台创建 Redis OSS（已禁用集群模式）集群 ElastiCache**
1. 登录AWS 管理控制台并打开 Amazon ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 从右上角的列表中，选择要在其中启动此集群的AWS区域。
1. 从导航窗格中，选择 **Get started**（入门）。
1. 选择 **Create VPC**（创建 VPC）并按照[创建虚拟私有云（VPC）](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/VPCs.CreatingVPC.html)中的步骤操作。
1. 在 ElastiCache 控制面板页面上，选择 **Valkey 缓存**或 **Redis OSS** 缓存。在本练习中，我们将选择 **Redis OSS 缓存**，然后选择**创建 Redis OSS** 缓存。
1. 在 **Cluster settings**（集群设置）下，执行以下操作：
1. 选择 **Configure and create a new cluster**（配置和创建新集群）。
1. 对于 **Cluster mode**（集群模式），选择 **Disabled**（已禁用）。
1. 对于 **Cluster info**（集群信息），为 **Name**（名称）输入一个值。
1. （可选）为 **Description**（描述）输入一个值。
1. 在 **Location**（位置）下：
------
#### [ AWS Cloud ]
1. 对于 **AWS Cloud**，我们建议您接受 **Multi-AZ**（多可用区）和 **Auto-failover**（自动失效转移）的默认设置。有关更多信息，请参阅使用[多可用区 ElastiCache 最大限度地缩短 Redis OSS 的停机时间](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/AutoFailover.html)。
1. 在 **Cluster settings**（集群设置）下
1. 对于 **Engine version**（引擎版本），选择一个可用的引擎版本。
1. 对于 **Port**（端口），使用默认端口 6379。如果您出于某个原因需要使用其他端口，请输入相应的端口号。
1. 对于**参数组**，选择一个参数组或创建一个新参数组。参数组控制集群的运行时参数。有关参数组的更多信息，请参阅[Valkey 和 Redis OSS 参数](ParameterGroups.Engine.md#ParameterGroups.Redis) 和[创建 ElastiCache 参数组](ParameterGroups.Creating.md)。
**注意**
当您选择要设置引擎配置值的参数组时，该参数组将应用于全局数据存储中的所有集群。在 **Parameter Groups（参数组）**页面上，是/否 **Global（全局）**属性指示参数组是否属于全局数据存储。
1. 对于 **Node type（节点类型）**，请选择向下箭头（![\[Downward-pointing triangle icon, typically used to indicate a dropdown menu.\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-DnArrow.png)）。在 **Change node type（更改节点类型）**对话框中，为所需节点类型选择 **Instance family（实例系列）**值。接着选择要用于此集群的节点类型，然后选择**保存**。
有关更多信息，请参阅 [选择节点大小](CacheNodes.SelectSize.md)。
如果您选择 r6gd 节点类型，则系统会自动启用数据分层。有关更多信息，请参阅 [ElastiCache 中的数据分层](data-tiering.md)。
1. 对于 **Number of replicas**（副本数），选择所需的只读副本数。如果您启用多可用区，则该数字必须介于 1-5 之间。
1. 在 **Connectivity**（连接）下
1. 对于 **Network type**（网络类型），选择此集群将支持的 IP 版本。
1. 对于**子网组**，请选择要应用于此集群的子网。 ElastiCache 使用该子网组选择子网和该子网内的 IP 地址以与您的节点关联。 ElastiCache 群集需要一个双堆栈子网 IPv4 并分配给它们 IPv6 的地址才能在双堆栈模式下运行，并且需要一个 IPv6仅限子网才能以-only模式运行。 IPv6
创建新的子网组时，输入其所属的 **VPC ID**。
有关更多信息，请参阅:
+ [在中选择网络类型 ElastiCache](network-type.md).
+ [在您的 VPC 中创建子网](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet)。
如果您是 [将 Local Zones 与 ElastiCache 结合使用](Local_zones.md)，则必须创建或选择位于本地区域中的子网。
有关更多信息，请参阅 [子网和子网组](SubnetGroups.md)。
1. 对于 **Availability zone placements**（可用区位置），您有两种选择：
+ **无偏好** — ElastiCache 选择可用区。
+ **Specify availability zones（指定可用区）**– 您为各集群指定可用区。
如果您选择指定可用区，则需从列表中为各分片中的每个集群选择可用区。
有关更多信息，请参阅 [为 ElastiCache 选择区域和可用区](RegionsAndAZs.md)。
1. 选择 **Next**（下一步）
1. 在**高级 Redis OSS 设置**下
1. 对于 **Security**（安全）：
1. 要加密您的数据，您有以下选项：
+ **Encryption at rest（静态加密）**– 对磁盘上存储的数据启用加密。有关更多信息，请参阅[静态加密](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/at-rest-encryption.html)。
**注意**
您可以选择提供不同的加密密钥，方法是选择 “**客户托管AWS KMS 密钥**” 并选择密钥。有关更多信息，请参阅[使用AWS KMS 客户自主管理型密钥](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/at-rest-encryption.html#using-customer-managed-keys-for-elasticache-security)。
+ **Encryption in-transit（传输中加密）**– 对传输中数据启用加密。有关更多信息，请参阅[传输中加密](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/in-transit-encryption.html)。对于 Redis OSS 及更高版本的 ElastiCache 引擎版本 6.0，如果您启用传输中加密，系统将提示您指定以下**访问**控制选项之一：
+ **No Access Control（无访问控制）**– 此选项为默认设置。这表示对用户访问集群的权限没有任何限制。
+ **User Group Access Control List（用户组访问控制列表）**– 选择具有集群访问权限的已定义用户组。有关更多信息，请参阅 [使用控制台和 CLI 管理用户组](Clusters.RBAC.md#User-Groups)。
+ **Redis AUTH 默认用户** – Valkey 或 Redis OSS 服务器的身份验证机制。有关更多信息，请参阅 [AUTH](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/auth.html)。
+ **AUTH** – Redis OSS 服务器的身份验证机制。有关更多信息，请参阅 [AUTH](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/auth.html)。
**注意**
对于 Redis OSS 3.2.6 以上的版本（版本 3.2.10 除外），只能选择 Redis OSS AUTH。
1. 对于**安全组**，选择要用于该集群的安全组。*安全组* 充当防火墙来控制对集群的网络访问。您可以为 VPC 使用默认安全组或创建新安全组。
有关安全组的更多信息，请参阅 *Amazon VPC 用户指南*中的[您的 VPC 的安全组](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)。
1. 如果需要定期计划自动备份，请选择**启用自动备份**，然后输入每个自动备份在被自动删除前保留的天数。如果您不希望定期计划自动备份，请清除 **Enable automatic backups** 复选框。不论是哪种情况，您始终可以选择创建手动备份。
有关备份和还原的更多信息，请参阅[快照和还原](backups.md)。
1. （可选）指定维护时段。*维护时段* 是每周中 ElastiCache 为您的集群计划系统维护的时间，通常以小时为时间长度。您可以允许 ElastiCache 选择维护时段的日期和时间（*No preference (无首选项)*），或者自行选择日期、时间和持续时间（*Specify maintenance window (指定维护时段)*）。如果您从列表中选择了*指定维护时段*，请为您的维护时段选择*开始日期*、*开始时间*和*持续时间*（以小时为单位）。所有时间均为 UCT 时间。
有关更多信息，请参阅 [管理 ElastiCache 集群维护](maintenance-window.md)。
1. （可选）对于 **Logs（日志）**：
+ 在 **Log format（日志格式）**下，选择 **Text（文本）**或 **JSON**。
+ 在**目标类型**下，选择**CloudWatch 日志**或 **Kinesis Fire** hose。
+ 在 “**日志目标**” 下，选择 “**新建**” 并输入您的 CloudWatch 日志组名称或 Firehose 直播名称，或者选择 **“选择现有”**，然后选择您的 CloudWatch 日志日志组名称或 Firehose 直播名称，
1. 对于**标签**，为了帮助您管理集群和其他 ElastiCache 资源，您可以以标签的形式为每个资源分配自己的元数据。有关更多信息，请参阅 [为资源添加 ElastiCache 标签](Tagging-Resources.md)。
1. 选择 **Next**（下一步）。
1. 查看您的所有输入和选择，然后进行任意所需的更正。当您准备好后，选择 **Create**（创建）。
------
#### [ On premises ]
1. 对于 **On premises**（本地），我们建议您保留 **Auto-failover**（自动失效转移）为启用状态。有关更多信息，请参阅使用多可用[区 ElastiCache 最大限度地缩短 Redis OSS 的停机时间](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/AutoFailover.html)
1. 要完成集群创建，请按照[使用 Outposts](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/ElastiCache-Outposts.html) 中的步骤操作。
------
一旦您的集群状态变为*可用*，您就可以向 Amazon 授予 EC2 访问权限、连接集群并开始使用它。有关更多信息，请参阅[步骤 3：授予对集群的访问权限](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey)和[步骤 4：连接到集群的节点](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey)。
**重要**
您的集群变为可用状态后，您便需要为集群处于活动状态的每个小时或分钟支付费用（即使您并未主动使用集群）。要停止此集群产生的费用，您必须将其删除。请参阅[删除中的集群 ElastiCache](Clusters.Delete.md)。
### 创建 Redis OSS（已禁用集群模式）集群（AWS CLI）
**Example**
下面的 CLI 代码创建一个无副本的 Redis OSS（已禁用集群模式）集群。
对于 Linux、macOS 或 Unix：
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine redis \
--num-cache-nodes 1 \
--snapshot-arns arn:aws:s3:::my_bucket/snapshot.rdb
```
对于 Windows：
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine redis ^
--num-cache-nodes 1 ^
--snapshot-arns arn:aws:s3:::my_bucket/snapshot.rdb
```
要在启用集群模式的情况下工作，请参阅以下主题：
+ 要使用控制台，请参阅[创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster)。
+ 要使用AWS CLI，请参阅[创建 Valkey 或 Redis OSS（已启用集群模式）集群（AWS CLI）](Clusters.Create.md#Clusters.Create.CLI.RedisCluster)。
## 步骤 3：授予对集群的访问权限
本节假设您熟悉启动和连接 Amazon EC2 实例。有关更多信息，请参阅 *[Amazon EC2 入门指南](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/)*。
所有 ElastiCache 集群均设计为可从 Amazon EC2 实例进行访问。最常见的情况是从同一个亚马逊虚拟私有云 (Amazon VPC) 中的亚马逊 EC2 实例访问 ElastiCache 集群，本练习就是这种情况。
原定设置情况下，对您的集群的网络访问仅限于用于创建集群的账户。必须先授权该 EC2 实例访问集群，然后才能从 EC2 实例连接到集群。所需的步骤取决于您是在 EC2-VPC 还是 EC2-Classic 中启动集群。
最常见的用例是部署在 EC2 实例上的应用程序需要连接到同一 VPC 中的集群。管理同一 VPC 中 EC2 实例和集群之间访问权限的最简单方法是执行以下操作：
1. 为集群创建 VPC 安全组。此安全组可用于限制对集群实例的访问权限。例如，可为此安全组创建自定义规则，允许使用您创建集群时分配给该集群的端口以及将用来访问集群的 IP 地址进行 TCP 访问。
Redis OSS 集群和复制组的默认端口为 `6379`。
**重要**
亚马逊 ElastiCache 安全组仅适用于*未*在亚马逊虚拟私有云环境 (VPC) 中运行的集群。如果您正在 Amazon Virtual Private Cloud 中运行，**安全组**将在控制台导航窗格中将不可用。
如果您在 Amazon VPC 中运行 ElastiCache 节点，则可以使用不同于安全组的 Amazon VPC 安全组来控制对集群的 ElastiCache 访问权限。有关在 Amazon VPC ElastiCache 中使用的更多信息，请参阅 [Amazon VPCs 与 ElastiCache 安全](VPCs.md)
1. 为您的 EC2 实例（Web 和应用程序服务器）创建 VPC 安全组。如果需要，此安全组可以允许通过 VPC 的路由表从 Internet 访问 EC2 实例。例如，您可以在此安全组上设置规则，允许 TCP 通过端口 22 访问 EC2 实例。
1. 在集群的安全组中创建自定义规则，允许来自您为 EC2 实例创建的安全组的连接。这将允许安全组的任何成员均可访问集群。
**注意**
如果您计划使用 [将 Local Zones 与 ElastiCache 结合使用](Local_zones.md)，请确保已将其启用。当您在该本地区域中创建子网组时，您的 VPC 也会扩展到该本地区域，并且您的 VPC 会将该子网视为任何其他可用区中的任何子网。所有相关网关和路由表都将自动调整。
**在 VPC 安全组中创建允许从另一安全组连接的规则**
1. 登录AWS管理控制台并在 [https://console.aws.amazon.com/](https://console.aws.amazon.com/vpc)vpc 上打开 Amazon VPC 控制台。
1. 在导航窗格中，选择**安全组**。
1. 选择或创建一个要用于集群实例的安全组。在**入站规则**下，选择**编辑入站规则**，然后选择**添加规则**。此安全组将允许访问其他安全组的成员。
1. 从 **Type** 中选择 **Custom TCP Rule**。
1. 对于 **Port Range**，指定在创建集群时使用的端口。
Redis OSS 集群和复制组的默认端口为 `6379`。
1. 在 **Source** 框中，开始键入安全组的 ID。从列表中选择您将用于 Amazon EC2 实例的安全组。
1. 完成后选择 **Save**。
![\[\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/VPC-Rules.png)
启用访问后，您现在就可以连接到节点，如下一部分中所述。
有关从其他 Amazon VPC、不同AWS区域甚至企业网络访问您的ElastiCache 集群的信息，请参阅以下内容：
+ [用于访问 Amazon VPC 中的 ElastiCache 缓存的访问模式](elasticache-vpc-accessing.md)
+ [从外部访问 ElastiCache 资源AWS](accessing-elasticache.md#access-from-outside-aws)
## 步骤 4：连接到集群节点
在继续之前，请完成[步骤 3：授予对集群的访问权限](#GettingStarted.AuthorizeAccess.redis)。
本节假设您已经创建了一个 Amazon EC2 实例并且可以连接到该实例。有关如何执行此操作的说明，请参阅《[Amazon EC2 入门指南》](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/)。
只有在您授权后，Amazon EC2 实例才能连接到集群节点。
### 查找您的节点端点
当您的集群处于*可用*状态并且您已获得访问权限时，您可以登录 Amazon EC2 实例并连接到该集群。为此，您必须先确定端点。
#### 查找 Valkey 或 Redis OSS（已禁用集群模式）集群端点（控制台）
如果 Redis OSS（已禁用集群模式）集群只有一个节点，则使用该节点的端点进行读取和写入操作。如果该集群具有多个节点，则有三种类型的端点，即*主端点*、*读取器端点*和*节点端点*。
主端点是一个 DNS 名称，始终解析为集群中的主节点。主端点不受集群更改的影响，如将只读副本提升为主角色。对于写入活动，我们建议您的应用程序连接到主端点。
读取器终端节点将在适用于 Redis OSS 集群的所有只读副本之间平均分配到该终端节点 ElastiCache 的传入连接。应用程序何时创建连接或应用程序如何（重复）使用连接等附加因素将决定流量分配。读取器端点会在添加或删除副本时实时跟踪集群更改。您可以将 For Redis OSS 集群的多个只读副本放在不同的AWS可用区 (AZ) 中，以确保读取器终端节点的高可用性。 ElastiCache
**注意**
读取器端点不是负载均衡器。它是一个 DNS 记录，将以循环方式解析为副本节点之一的 IP 地址。
对于读取活动，应用程序还可以连接到集群中的任何节点。与主端点不同，节点端点会解析为特定端点。如果您在您的集群中进行更改（例如添加或删除副本），则必须在您的应用程序中更新节点端点。
**查找 Redis OSS（已禁用集群模式）集群的端点**
1. 登录AWS 管理控制台并打开 ElastiCache 控制台，网址为[ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 从导航窗格中，选择 **Redis OSS 缓存**。
集群屏幕将显示一个列表，其中包含任何现有 Valkey 或 Redis OSS 无服务器缓存、Redis OSS（已禁用集群模式）和 Redis OSS（已启用集群模式）集群。选择在 [创建 Redis OSS（已禁用集群模式）集群（控制台）](#Clusters.Create.CON.Redis-gs) 部分中创建的集群。
1. 要查找集群的主 and/or 读取器终端节点，请选择集群的名称（不是单选按钮）。
![\[图片：Redis OSS（已禁用集群模式）集群的主端点\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)
*Redis OSS（已禁用集群模式）集群的主端点和读取器端点*
如果该集群只有一个节点，则没有主端点，您可以继续下一步。
1. 如果 Redis OSS（已禁用集群模式）集群有副本节点，您可以通过选择此集群的名称、然后选择**节点**选项卡来找到集群副本的节点端点。
此时会显示节点屏幕，其中列出了集群中的每个节点（主节点和副本节点）及其端点。
![\[图片：Redis OSS（已禁用集群模式）集群的节点端点\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)
*Redis OSS（已禁用集群模式）集群的节点端点*
1. 将端点复制到剪贴板：
1. 逐一找到要复制的端点。
1. 直接选择端点前面的复制图标。
端点现已复制到剪贴板。有关使用端点连接到节点的信息，请参阅 [连接到节点](nodes-connecting.md)。
Redis OSS（已禁用集群模式）主端点类似以下内容。根据是否已启用传输中加密而有所不同。
**未启用传输中加密**
```
clusterName.xxxxxx.nodeId.regionAndAz.cache.amazonaws.com:port
redis-01.7abc2d.0001.usw2.cache.amazonaws.com:6379
```
**已启用传输中加密**
```
master.clusterName.xxxxxx.regionAndAz.cache.amazonaws.com:port
master.ncit.ameaqx.use1.cache.amazonaws.com:6379
```
为进一步了解如何查找您的端点，请参阅您正在运行的引擎和集群类型的相关主题。
+ [查找 ElastiCache 中的缓存连接端点](Endpoints.md)
+ [查找 Valkey 或 Redis OSS（已启用集群模式）集群的端点（控制台）](Endpoints.md#Endpoints.Find.RedisCluster) – 您需要集群的配置端点。
+ [查找端点（AWS CLI）](Endpoints.md#Endpoints.Find.CLI)
+ [查找端点（ElastiCache API）](Endpoints.md#Endpoints.Find.API)
### 连接到 Valkey 或 Redis OSS 集群或复制组（Linux）
现在您已经有了所需的终端节点，可以登录 EC2 实例并连接到集群或复制组。在以下示例中，您使用 *valkey-cli* 实用工具连接到集群。最新版本的 valkey-cli 还支持连接 encryption/authentication 已启 SSL/TLS 用的集群。
以下示例使用运行亚马逊 Linux 和亚马逊 Linux 2 的亚马逊 EC2 实例。有关使用其他 Linux 发行版安装和编译 valkey-cli 的详细信息，请参阅特定操作系统的文档。
**注意**
此过程包括使用仅供计划外使用的 valkey-cli 实用工具测试连接。有关受支持客户端的列表，请参阅 [Valkey 文档](https://valkey.io/)。有关与 with AWS SDKs 一起使用的示例 ElastiCache，请参见[教程：Python 和 ElastiCache 入门](ElastiCache-Getting-Started-Tutorials.md)。
#### 连接到已禁用集群模式的未加密的集群
1. 运行以下命令以连接到集群，并将*primary-endpoint*和*port number*替换为集群的终端节点和您的端口号。（Valkey 和 Redis OSS 的默认端口为 6379。）
```
src/valkey-cli -h primary-endpoint -p port number
```
命令提示符的结果类似于以下内容：
```
primary-endpoint:port number
```
1. 现在您就可以运行 Valkey 和 Redis OSS 命令了。
```
set x Hello
OK
get x
"Hello"
```
#### 连接到已启用集群模式的未加密集群
1. 运行以下命令以连接到集群，并将*configuration-endpoint*和*port number*替换为集群的终端节点和您的端口号。（Valkey 和 Redis OSS 的默认端口为 6379。）
```
src/valkey-cli -h configuration-endpoint -c -p port number
```
**注意**
在上述命令中，选项 -c 可遵循 [-ASK 和 -MOVED 重新导向](https://redis.io/topics/cluster-spec)启用集群模式。
命令提示符的结果类似于以下内容：
```
configuration-endpoint:port number
```
1. 现在您就可以运行 Valkey 和 Redis OSS 命令了。请注意，重新导向发生是因为您使用 -c 选项启用了它。如果未启用重新导向，则命令将返回 MOVED 错误。有关 MOVED 错误的更多信息，请参阅[集群规范](https://valkey.io/topics/cluster-spec)。
```
set x Hi
-> Redirected to slot [16287] located at 172.31.28.122:6379
OK
set y Hello
OK
get y
"Hello"
set z Bye
-> Redirected to slot [8157] located at 172.31.9.201:6379
OK
get z
"Bye"
get x
-> Redirected to slot [16287] located at 172.31.28.122:6379
"Hi"
```
#### 连接到 Encryption/Authentication 已启用的集群
默认情况下，valkey-cli 在连接到 Valkey 和 Redis OSS 时使用未加密的 TCP 连接。该选项 SSL/TLS 在编译 valkey-cli 时`BUILD_TLS=yes`启用，如上一节所示。[下载并设置命令行访问权限](set-up.md#Download-and-install-cli)启用 AUTH 是可选的。但是，您必须启用传输过程中的加密才能启用 AUTH。有关 ElastiCache 加密和身份验证的更多详细信息，请参阅[ElastiCache 传输中加密 (TLS)](in-transit-encryption.md)。
**注意**
您可以通过 valkey-cli 使用选项 `--tls` 连接到已启用和已禁用集群模式的加密集群。如果集群设置了 AUTH 令牌，则可以使用选项 `-a` 以提供 AUTH 密码。
在以下示例中，请务必使用集群*port number*的终端节点和端口号替换*cluster-endpoint*和。（Redis OSS 的默认端口为 6379。）
**连接到已禁用集群模式的加密群集**
以下示例连接到已启用加密和身份验证的集群：
```
src/valkey-cli -h cluster-endpoint --tls -a your-password -p port number
```
以下示例连接到仅启用加密的集群：
```
src/valkey-cli -h cluster-endpoint --tls -p port number
```
**连接到已启用集群模式的加密群集**
以下示例连接到已启用加密和身份验证的集群：
```
src/valkey-cli -c -h cluster-endpoint --tls -a your-password -p port number
```
以下示例连接到仅启用加密的集群：
```
src/valkey-cli -c -h cluster-endpoint --tls -p port number
```
连接到集群后，您可以为未加密集群运行上述示例中的 Valkey 或 Redis OSS 命令。
#### valkey-cli 或 redis-CLI 的替代方案
如果集群未启用集群模式，并且您需要与集群建立连接以进行短期测试（但不经过 valkey-cli 或 redis-cli 编译），则可以使用 telnet 或 openssl。在以下示例命令中，请务必使用集群*port number*的终端节点和端口号替换*cluster-endpoint*和。（Redis OSS 的默认端口为 6379。）
以下示例连接到启用了加密 and/or 身份验证的集群模式已禁用的集群：
```
openssl s_client -connect cluster-endpoint:port number
```
如果集群已设置密码，请先连接到集群。连接后，使用以下命令对集群进行身份验证，然后按 `Enter` 键。在以下示例中，*your-password*替换为您的集群的密码。
```
Auth your-password
```
以下示例连接到未启用加密或身份验证的已禁用集群模式的集群：
```
telnet cluster-endpoint port number
```
### 连接到 Valkey 或 Redis OSS 集群或复制组（Windows）
要使用 Valkey 或 Redis OSS CLI 从 EC2 Windows 实例连接到集群，你必须下载 v *alkey-cli* 包并使用 *valkey-cli.exe* 从 Windows 实例连接到 Valkey 或 Redis OSS 集群。 EC2
在以下示例中，您使用 *valkey-cli* 实用工具连接到未启用加密的运行 Valkey 或 Redis OSS 的集群。有关 Valkey 和可用命令的更多信息，请参阅 Valkey 网站上的 [Valkey 命令](http://valkey.io/commands)。
**使用 *valkey-cli* 连接未启用加密的 Valkey 或 Redis OSS 集群**
1. 使用您选择的连接实用程序连接到您的 Amazon EC2 实例。有关如何连接亚马逊 EC2 实例的说明，请参阅《[亚马逊 EC2 入门指南》](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/)。
1. 将链接复制并粘贴到互联网浏览器[https://github.com/microsoftarchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.zip](https://github.com/microsoftarchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.zip)中，即可从可用版本中下载 Redis OSS 客户端的 zip 文件，网址为 GitHub [https://github.com/microsoftarchive/redis/releases/tag/win-3.0.504](https://github.com/microsoftarchive/redis/releases/tag/win-3.0.504)
将 zip 文件提取到您指定的文件夹/路径。
打开命令提示符并更改为 Valkey 目录，然后运行命令 `c:\Valkey>valkey-cli -h Valkey_Cluster_Endpoint -p 6379`。
例如：
```
c:\Valkey>valkey-cli -h cmd.xxxxxxx.ng.0001.usw2.cache.amazonaws.com -p 6379
```
1. 运行 Valkey 或 Redis OSS 命令。
您现已连接至集群并且可以按以下方式运行 Valkey 或 Redis OSS 命令。
```
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
get b // Get value for key "b" results in miss
(nil)
set b "Good-bye" EX 5 // Set key "b" with a string value and a 5 second expiration
"Good-bye"
get b // Get value for key "b"
"Good-bye"
// wait >= 5 seconds
get b
(nil) // key has expired, nothing returned
quit // Exit from valkey-cli
```
# 删除集群
只要集群处于*可用* 状态，您就绪需为它付费，无论您是否主动使用它。要停止产生费用，请删除此集群。
**警告**
当您删除 ElastiCache 集群时，您的手动快照会被保留。您也可以在删除集群之前创建最终快照。自动缓存快照不会保留。有关更多信息，请参阅 [快照和还原](backups.md)。
创建最终快照需要 `CreateSnapshot` 权限。如果没有此权限，API 调用将失败，并出现 `Access Denied` 异常。
## 使用AWS 管理控制台
以下过程从您的部署中删除单个集群。要删除多个集群，请对要删除的每个集群重复此过程。在开始删除一个集群的过程之前，您无需等待删除另一个集群完成。
**删除集群**
1. 登录AWS 管理控制台并打开 Amazon ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 在 ElastiCache 引擎控制面板中，选择 Valkey 或 Redis OSS。
此时会显示运行该引擎的所有缓存的列表。
1. 要选择要删除的集群，请从集群列表中选择该集群的名称。在这种情况下，是您在 [步骤 2：创建集群](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.CreateCluster.valkey) 创建的集群的名称。
**重要**
您一次只能从 ElastiCache 控制台删除一个集群。选择多个集群会禁用删除操作。
1. 对于**操作**，选择**删除**。
1. 在**删除集群**确认屏幕中，键入集群名称并选择**最终备份**。然后选择**删除**以删除集群，或选择**取消**以保留集群。
如果选择了 **Delete**，集群的状态将变为*正在删除*。
只要您的集群不再在集群列表中列出，您就无需为该集群付费。
## 使用AWS CLI
以下代码删除集群 `my-cluster`。在这种情况下，将 `my-cluster` 替换为您在 [步骤 2：创建集群](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.CreateCluster.valkey) 中创建的集群的名称。
```
aws elasticache delete-cache-cluster --cache-cluster-id my-cluster
```
`delete-cache-cluster` CLI 操作只会删除一个集群。要删除多个集群，请对要删除的每个缓存集群调用 `delete-cache-cluster`。在删除一个集群之前，您无需等待删除另一个集群的完成。
对于 Linux、macOS 或 Unix：
```
aws elasticache delete-cache-cluster \
--cache-cluster-id my-cluster \
--region us-east-2
```
对于 Windows：
```
aws elasticache delete-cache-cluster ^
--cache-cluster-id my-cluster ^
--region us-east-2
```
有关更多信息，请参阅 f AWS CLI or ElastiCache 主题[https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html)。
# 其他 ElastiCache 教程和视频
以下教程着重介绍了 Amazon ElastiCache 用户关注的任务。
+ [ElastiCache 视频](#tutorial-videos)
+ [教程：配置 Lambda 函数，以便在 Amazon VPC 中访问 Amazon ElastiCache](https://docs.aws.amazon.com/lambda/latest/dg/vpc-ec.html)
## ElastiCache 视频
以下视频可以帮助您学习 Amazon ElastiCache 的基本概念和高级概念。有关 AWS 培训的信息，请参阅 [AWS 培训和认证](https://aws.amazon.com/training/)。
**Topics**
+ [宣传视频](#WhatIs.Videos.Beginning)
+ [高级视频](#WhatIs.Videos.Advanced)
### 宣传视频
以下视频将向您介绍 Amazon ElastiCache。
**Topics**
+ [AWS re:Invent 2020：Amazon ElastiCache 中的新增功能](#WhatIs.Videos.Beginning.2020)
+ [AWS re:Invent 2019：Amazon ElastiCache 中的新增功能](#WhatIs.Videos.Beginning.2019)
+ [AWS re:Invent 2017：Amazon ElastiCache 中的新增功能](#WhatIs.Videos.Beginning.2017)
+ [DAT204 – 在 AWS NoSQL 服务上构建可扩展应用程序 (re:Invent 2015)](#WhatIs.Videos.Beginning.2015.DAT204)
+ [DAT207 - 利用 Amazon ElastiCache 提升应用程序性能 (AWS re:Invent 2013)](#WhatIs.Videos.Beginning.2013.DAT207)
#### AWS re:Invent 2020：Amazon ElastiCache 中的新增功能
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/O9mqbIYJXWE)
#### AWS re:Invent 2019：Amazon ElastiCache 中的新增功能
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/SaGW_Bln3qA)
#### AWS re:Invent 2017：Amazon ElastiCache 中的新增功能
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/wkGn1TzCgnk)
#### DAT204 – 在 AWS NoSQL 服务上构建可扩展应用程序 (re:Invent 2015)
在本演讲中，我们将介绍 NoSQL 数据库的优势并浏览 AWS 提供的主要 NoSQL 服务，即 Amazon DynamoDB 和 Amazon ElastiCache。然后，我们听听两家占据领先地位的客户 Expedia 和 Mapbox 讲述他们的使用案例和面临的架构挑战，以及他们如何使用 AWS NoSQL 服务（包括设计模式和最佳实践）来解决这些难题。完成本培训之后，您将更好地了解 NoSQL 及其强大的功能，满怀信心地准备好解决所面临的数据库挑战。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/ie4dWGT76LM)
#### DAT207 - 利用 Amazon ElastiCache 提升应用程序性能 (AWS re:Invent 2013)
本视频介绍了如何使用 Amazon ElastiCache 轻松部署内存中的缓存系统来提升应用程序性能。我们将向您介绍如何使用 Amazon ElastiCache 来改善应用程序延迟并减少数据库服务器上的负载。我们还将向您说明如何构建可轻松管理并随应用程序不断增多而扩展的缓存层。在此演讲中，我们将复习可通过启用缓存获益的各种方案和使用案例，并讨论 Amazon ElastiCache 提供的各种功能。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/odMmdPBV8hM)
### 高级视频
以下视频包括更高级的 Amazon ElastiCache 主题。
**Topics**
+ [利用 Amazon ElastiCache 最佳实践进行设计以取得成功 (re:Invent 2020)](#WhatIs.Videos.Advanced.2020.DAT305)
+ [使用 Amazon ElastiCache 增强您的实时应用程序 (re:Invent 2019)](#WhatIs.Videos.Advanced.2019.DAT305)
+ [最佳实践：将 Redis OSS 集群从 Amazon EC2 迁移到 ElastiCache（re:Invent 2019）](#WhatIs.Videos.Advanced.2019.DAT358)
+ [使用 Amazon ElastiCache 和 Amazon Aurora STP11 扩展 Fantasy Sports 平台 (re:Invent 2018)](#WhatIs.Videos.Advanced.2019)
+ [利用 Amazon ElastiCache 在云中实现可靠且可扩展的 Redis OSS（re:Invent 2018）](#WhatIs.Videos.AdvancedDD.2018)
+ [ElastiCache 深入探究：内存数据存储的设计模式 (re:Invent 2018)](#WhatIs.Videos.AdvancedDD.2019)
+ [DAT305 - 深入探究 Amazon ElastiCache (re:Invent 2017)](#WhatIs.Videos.Advanced.2017.DAT305)
+ [DAT306 - 深入探究 Amazon ElastiCache (re:Invent 2016)](#WhatIs.Videos.Advanced.2016.DAT306)
+ [DAT317 - IFTTT 如何使用 ElastiCache for Redis OSS 来预测事件（re:Invent 2016）](#WhatIs.Videos.Advanced.2016.DAT317)
+ [DAT407 - 深入探究 Amazon ElastiCache (re:Invent 2015)](#WhatIs.Videos.Advanced.2015.DAT407)
+ [SDD402 - 深入探究 Amazon ElastiCache (re:Invent 2014)](#WhatIs.Videos.Advanced.2014.SDD402)
+ [DAT307 - 深入探究 Amazon ElastiCache 架构和设计模式 (re:Invent 2013)](#WhatIs.Videos.Advanced.2013.DAT307)
#### 利用 Amazon ElastiCache 最佳实践进行设计以取得成功 (re:Invent 2020)
随着基于 Redis OSS 构建的业务关键型实时应用程序的爆炸式增长，可用性、可扩展性和安全性已成为首要考虑因素。了解通过线上扩展、跨多可用区部署的高可用性和安全配置设置 Amazon ElastiCache 的最佳实践，以取得成功。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/_4SkEy6r-C4)
#### 使用 Amazon ElastiCache 增强您的实时应用程序 (re:Invent 2019)
随着云采用的快速发展及其支持的新场景，应用程序需要微秒级的延迟和高吞吐量来支持每秒数百万次的请求。开发人员传统上依靠专门的硬件和解决方法（例如将基于磁盘的数据库与数据缩减技术相结合）来管理实时应用程序的数据。这些方法可能很昂贵，而且无法扩展。了解如何通过使用完全托管式的内存中 Amazon ElastiCache 来提高实时应用程序的性能以获得极限性能、高可扩展性、可用性和安全性。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/v0GfpL5jfns)
#### 最佳实践：将 Redis OSS 集群从 Amazon EC2 迁移到 ElastiCache（re:Invent 2019）
自己管理 Redis OSS 集群可能很困难。您必须持续预置硬件、修补软件、备份数据和监控工作负载。通过新发布的 Amazon ElastiCache 联机迁移功能，您现在可以在禁用集群模式的情况下轻松地将数据从 Amazon EC2 上的自托管式 Redis OSS 移动到完全托管式的 Amazon ElastiCache。在本次演讲中，您将了解新的联机迁移工具，观看演示，更重要的是学习亲自动手的最佳实践，以便顺利迁移到 Amazon ElastiCache。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Rpni5uPe0uI)
#### 使用 Amazon ElastiCache 和 Amazon Aurora STP11 扩展 Fantasy Sports 平台 (re:Invent 2018)
Dream11 是一家印度的领先体育科技初创公司。该公司拥有超过 4000 万用户参加了多种运动，包括梦幻板球、足球和篮球。目前该公司为 100 万并发用户提供服务，这些用户每分钟可产生 300 万个请求，响应时间仅为 50 毫秒。在本次演讲中，Dream11 CTO Amit Sharma 将介绍该公司如何使用 Amazon Aurora 和 Amazon ElastiCache 来处理闪存流量，这些流量在 30 秒的响应窗口内可能增加三倍。Sharma 还将探讨在不锁定的情况下扩展事务，并分享处理闪存流量的步骤，从而为 500 万日活跃用户提供服务。完整标题：AWS re:Invent 2018：使用 Amazon ElastiCache 和 Amazon Aurora STP11 扩展 Fantasy Sports 平台
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/hIPOLeEjVQY)
#### 利用 Amazon ElastiCache 在云中实现可靠且可扩展的 Redis OSS（re:Invent 2018）
本部分将介绍与 Redis OSS 兼容的服务 Amazon ElastiCache for Redis OSS 的功能和增强功能。演讲内容涵盖其主要功能，如 Redis OSS 5、可扩展性和性能提升、安全性和合规性等。我们还将探讨即将推出的功能和客户案例研究。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/pgXEnAcTNPI)
#### ElastiCache 深入探究：内存数据存储的设计模式 (re:Invent 2018)
在本次演讲中，我们将深入了解 Amazon ElastiCache 的设计和架构内幕。了解我们的 Redis OSS 和 Memcached 产品的常见设计模式，以及客户如何利用这些产品执行内存中数据处理以减小延迟和增加应用程序吞吐量。我们还将回顾 ElastiCache 最佳实践、设计模式以及不合理的模式。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/QxcB53mL_oA)
#### DAT305 - 深入探究 Amazon ElastiCache (re:Invent 2017)
深入探究 Amazon ElastiCache 的设计和架构内幕。了解我们的 Memcached 和 Redis OSS 产品的常见设计模式，以及客户如何利用这些产品执行内存中操作以减小延迟和增加应用程序吞吐量。在此视频中，我们将回顾 ElastiCache 最佳实践、设计模式以及不合理的模式。
此视频推出了以下内容：
+ ElastiCache for Redis OSS 在线重新分片
+ ElastiCache 安全性和加密
+ ElastiCache for Redis OSS 版本 3.2.10
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/_YYBdsuUq2M)
#### DAT306 - 深入探究 Amazon ElastiCache (re:Invent 2016)
深入探究 Amazon ElastiCache 的设计和架构内幕。了解我们的 Memcached 和 Redis OSS 产品的常见设计模式，以及客户如何利用这些产品执行内存中操作以减小延迟和增加应用程序吞吐量。在此演讲中，我们将回顾与 ElastiCache 相关的最佳实践、设计模式以及不合理的模式。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/e9sN15a7utI)
#### DAT317 - IFTTT 如何使用 ElastiCache for Redis OSS 来预测事件（re:Invent 2016）
IFTTT 是一项免费服务，能够使人们借助所喜爱的服务完成更多的任务，从实现简单任务自动化到转换人们相互交往以及控制家居设备的方式。IFTTT 使用 ElastiCache for Redis OSS 来存储事务处理运行历史记录和时间表预测以及 Amazon S3 上日志文档的索引。观看本次会议，了解人们如何利用 LUA 的脚本功能和 Redis OSS 的数据类型来完成一些在其他地方不可能完成的事情。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/eQbsXN0kcc0)
#### DAT407 - 深入探究 Amazon ElastiCache (re:Invent 2015)
深入了解 Amazon ElastiCache 的设计和架构内幕。您将了解我们的 Memcached 和 Redis OSS 产品的常见设计模式，以及客户如何利用这些产品执行内存中操作并缩短延迟时间，同时提高应用程序的吞吐量。在此演讲中，我们将回顾与 Amazon ElastiCache 相关的最佳实践、设计模式以及不合理的模式。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/4VfIINg9DYI)
#### SDD402 - 深入探究 Amazon ElastiCache (re:Invent 2014)
在此视频中，我们将检查常见缓存使用案例、ElastiCache for Memcached 和 ElastiCache for Redis OSS 引擎、帮助确定哪种引擎更能满足您需求的模式、一致性哈希以及更多快速构建方法和可扩展的应用程序。Adobe 的首席科学家 Frank Wiebe 将详细介绍 Adobe 如何使用 Amazon ElastiCache 改善客户体验和扩展业务。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/cEkHBqhQnog)
#### DAT307 - 深入探究 Amazon ElastiCache 架构和设计模式 (re:Invent 2013)
在本视频中，我们将检查缓存、缓存策略、向外扩展和监控。我们也将比较 ElastiCache for Memcached 和 ElastiCache for Redis OSS 引擎。在此演讲中，我们还将回顾与 Amazon ElastiCache 相关的最佳实践和设计模式。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/me0Tw13O1H4)
# 在 ElastiCache 中管理节点
节点是 Amazon ElastiCache 部署中的最小构建数据块。它是固定大小、与网络连接的安全 RAM 块。每个节点都运行创建集群或最后一次修改集群时选择的引擎。每个节点都有自己的域名服务（DNS）名称和端口。支持多种类型的 ElastiCache 节点，每种类型的节点具有不同的关联内存量和计算能力。
有关要使用的节点大小的更详细讨论，请参阅[选择节点大小](CacheNodes.SelectSize.md)。
一般而言，由于支持分片，Valkey 或 Redis OSS（已启用集群模式）部署具有许多更小的节点。相比之下，Valkey 或 Redis OSS（已禁用集群模式）部署在集群中的节点数量更少、规模更大。有关要使用的节点大小的更详细讨论，请参阅[选择节点大小](CacheNodes.SelectSize.md)。
**Topics**
+ [查看 ElastiCache 节点状态](Nodes.viewing.md)
+ [Valkey 或 Redis OSS 节点和分片](CacheNodes.NodeGroups.md)
+ [连接到节点](nodes-connecting.md)
+ [受支持的节点类型](CacheNodes.SupportedTypes.md)
+ [重启节点](nodes.rebooting.md)
+ [替换节点（Valkey 和 Redis OSS）](CacheNodes.NodeReplacement.md)
+ [替换节点（Memcached）](CacheNodes.NodeReplacement-mc.md)
+ [预留节点](CacheNodes.Reserved.md)
+ [迁移上一代节点](CacheNodes.NodeMigration.md)
涉及节点的一些重要操作如下：
+ [向 ElastiCache 集群添加节点](Clusters.AddNode.md)
+ [从 ElastiCache 集群中移除节点](Clusters.DeleteNode.md)
+ [缩放 ElastiCache](Scaling.md)
+ [查找 ElastiCache 中的缓存连接端点](Endpoints.md)
+ [自动识别集群（Memcached）中的节点](AutoDiscovery.md)
# 查看 ElastiCache 节点状态
使用[ElastiCache 控制台](https://console.aws.amazon.com/elasticache/)，您可以快速访问 ElastiCache 节点的状态。 ElastiCache 节点的状态表示该节点的运行状况。您可以使用以下过程在 Amazon ElastiCache 控制台、AWS CLI命令或 API 操作中查看 ElastiCache 节点状态。
下表列出了 ElastiCache 节点可能的状态值。此表还显示您是否需要为该 ElastiCache 节点付费。
| **Type** | **已计费** | **描述** |
| --- | --- | --- |
| `available` | 计费 | 该 ElastiCache 节点运行状况良好，可用。 |
| `creating` | 不计费 | 正在创建 ElastiCache 节点。节点正在创建，无法访问。 |
| `deleting` | 不计费 | 正在删除该 ElastiCache 节点。 |
| `modifying` | 计费 | 由于客户要求修改该 ElastiCache 节点，因此正在修改该节点。 |
| `updating` | 计费 | **更新**状态表明 Amazon ElastiCache 节点存在以下一项或多项情况： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/Nodes.viewing.html) |
| `rebooting cluster nodes` | 计费 | 由于客户请求或 Amazon ElastiCache 流程要求重启节点，该 ElastiCache 节点正在重启。 |
| `incompatible_parameters` | 不计费 | Amazon ElastiCache 无法启动该节点，因为节点的参数组中指定的参数与该节点不兼容。请恢复参数更改或使这些更改与数据库节点相兼容，以便重新访问节点。有关不兼容参数的更多信息，请查看该 ElastiCache 节点[的事件](https://us-east-1.console.aws.amazon.com/elasticache/home?region=us-east-1#/events)列表。 |
| `incompatible_network` | 不计费 | 网络不兼容状态表示 Amazon 节点存在以下一项或多项情况： ElastiCache [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/Nodes.viewing.html) |
| `restore_failed` | 不计费 | 恢复失败状态表明 Amazon 节点存在以下情况之一： ElastiCache [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/Nodes.viewing.html) |
| `snapshotting` | 计费 | ElastiCache 正在创建 Valkey 或 Redis OSS 节点的快照。 |
## 使用控制台查看 ElastiCache 节点状态
要使用控制台查看 ElastiCache 节点的状态，请执行以下操作：
1. 登录AWS 管理控制台并打开 Amazon ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 在导航窗格中，选择 **Redis OSS 集群**或 **Memcached 集群**。将出现 **“缓存” 页面**，其中包含 ElastiCache 节点列表。还显示每个节点的状态值。
1. 然后，您可以导航到缓存的**服务更新**选项卡，以显示适用于缓存的服务更新列表。
## 使用查看 ElastiCache 节点状态AWS CLI
要使用查看 ElastiCache 节点及其状态信息AWS CLI，请使用`describe-cache-cluster`命令。例如，以下AWS CLI命令显示每个 ElastiCache 节点。
```
aws elasticache describe-cache-clusters
```
## 通过 API 查看 ElastiCache 节点状态
要使用 Amazon ElastiCache API 查看 ElastiCache 节点的状态，请调用`DescribeCacheClusteroperation`带`ShowCacheNodeInfo`标志的，以检索有关各个缓存节点的信息。
# Valkey 或 Redis OSS 节点和分片
分片（在 API 和 CLI 中，为节点组）是节点层次结构，每个都包含在一个集群中。分片支持复制。在分片中，一个节点充当读/写主节点。分片中的所有其他节点充当主节点的只读副本。Valkey 或 Redis OSS 3.2 及更高版本支持集群（在 API 和 CLI 中为复制组）内的多个分片。有了这种支持，您就可以在 Valkey 或 Redis OSS（已启用集群模式）集群中对数据进行分区。
下图说明了 Valkey 或 Redis OSS（已禁用集群模式）集群与 Valkey 或 Redis OSS（已启用集群模式）集群之间的区别。
![\[图片：Redis（已禁用集群模式）和 Valkey 或 Redis OSS（已启用集群模式）分片（API/CLI：节点组）\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-NodeGroups.png)
Valkey 或 Redis OSS（已启用集群模式）集群支持通过分片进行复制。API 操作 [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html)（CLI：[describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html)）可以列出带有成员节点的节点组、节点在节点组中的角色以及其他信息。
创建 Valkey 或 Redis OSS 集群时，您需要指定是否要创建已启用集群模式的集群。Valkey 或 Redis OSS（已禁用集群模式）集群永远只有一个分片，可通过添加（总计最多 5 个）或删除只读副本节点进行水平扩展。有关更多信息，请参阅 [使用复制组时的高可用性](Replication.md)、[为 Valkey 或 Redis OSS（已禁用集群模式）添加只读副本](Replication.AddReadReplica.md) 或 [为 Valkey 或 Redis OSS（已禁用集群模式）删除只读副本](Replication.RemoveReadReplica.md)。Valkey 或 Redis OSS（已禁用集群模式）集群也可以通过更改节点类型进行纵向扩展。有关更多信息，请参阅 [扩缩单节点 Valkey 或 Redis OSS（已禁用集群模式）副本节点](Scaling.RedisReplGrps.md)。
如果引擎为 Valkey 或 Redis OSS 5.0.6 或更高版本，您可以将每个集群的节点或分片限制增至最多 500 个。例如，您可以选择配置一个 500 节点的集群，范围介于 83 个分片（一个主分片和 5 个副本分片）和 500 个分片（一个主分片，无副本分片）之间。确保可提供足够的 IP 地址来满足增长需求。常见的陷阱包括子网组中的子网 CIDR 范围太小，或者子网被其他集群共享和大量使用。有关更多信息，请参阅 [创建子网组](SubnetGroups.Creating.md)。
对于低于 5.0.6 的版本，每个集群的限制为 250。
若要请求提高限制，请参阅 [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) 并选择限制类型 **Nodes per cluster per instance type（每个实例类型的每个集群的节点数）**。
在创建 Valkey 或 Redis OSS（已启用集群模式）集群后，您可以对其进行更改（横向缩减或扩展）。有关更多信息，请参阅[缩放 ElastiCache](Scaling.md)和[替换节点（Valkey 和 Redis OSS）](CacheNodes.NodeReplacement.md)。
创建新集群时，可以使用旧集群中的数据为其设定种子，以免从头开始创建。仅当集群组具有与旧集群相同数量的分片时，此方法才有效。如果您需要更改节点类型或引擎版本，这样做会很有用。有关更多信息，请参阅[进行手动备份](backups-manual.md)和[从备份还原到新缓存](backups-restoring.md)。
# 连接到节点
## 连接到 Valkey 或 Redis OSS 节点
在尝试与 Valkey 或 Redis OSS 集群中的节点连接之前，您必须拥有适用于这些节点的端点。要找到终端节点，请参阅：
+ [查找 Valkey 或 Redis OSS（已禁用集群模式）集群端点（控制台）](Endpoints.md#Endpoints.Find.Redis)
+ [查找 Valkey 或 Redis OSS（已启用集群模式）集群的端点（控制台）](Endpoints.md#Endpoints.Find.RedisCluster)
+ [查找端点（AWS CLI）](Endpoints.md#Endpoints.Find.CLI)
+ [查找端点（ElastiCache API）](Endpoints.md#Endpoints.Find.API)
在以下示例中，您使用 *valkey-cli* 实用工具连接到运行 Valkey 或 Redis OSS 的集群。
**注意**
有关可用命令的更多信息，请参阅[命令](http://valkey.io/commands)网页。
**使用 *valkey-cli* 连接到 Valkey 或 Redis OSS 集群**
1. 使用您选择的连接实用工具连接到 Amazon EC2 实例。
**注意**
有关如何连接到 Amazon EC2 实例的说明，请参阅 [Amazon EC2 入门指南](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/)。
1. 要生成 `valkey-cli`，请下载并安装 GNU Compiler Collection (`gcc`)。在 EC2 实例的命令提示符下输入下面的命令，然后在确认提示符下输入 `y`。
```
sudo yum install gcc
```
此时会显示类似以下内容的输出。
```
Loaded plugins: priorities, security, update-motd, upgrade-helper
Setting up Install Process
Resolving Dependencies
--> Running transaction check
...(output omitted)...
Total download size: 27 M
Installed size: 53 M
Is this ok [y/N]: y
Downloading Packages:
(1/11): binutils-2.22.52.0.1-10.36.amzn1.x86_64.rpm | 5.2 MB 00:00
(2/11): cpp46-4.6.3-2.67.amzn1.x86_64.rpm | 4.8 MB 00:00
(3/11): gcc-4.6.3-3.10.amzn1.noarch.rpm | 2.8 kB 00:00
...(output omitted)...
Complete!
```
1. 下载并编译 *valkey-cli* 实用工具。此实用工具包含在 Valkey 软件发布版中。在 EC2 实例的命令提示符处，键入以下命令：
**注意**
对于 Ubuntu 系统，在运行 `make` 之前，先运行 `make distclean`。
```
wget https://github.com/valkey-io/valkey/archive/refs/tags/8.0.0.tar.gz
tar xvzf valkey-8.0.0.tar.gz
cd valkey-8.0.0
make distclean # ubuntu systems only
make
```
1. 在 EC2 实例的命令提示符处，键入以下命令。
```
src/valkey-cli -c -h mycachecluster.eaogs8.0001.usw2.cache.amazonaws.com -p 6379
```
此时会显示类似于以下内容的 Valkey 或 Redis OSS 命令提示符。
```
redis mycachecluster.eaogs8.0001.usw2.cache.amazonaws.com 6379>
```
1. 运行 Valkey 或 Redis OSS 命令测试连接。
您现已连接至集群并且可以运行 Valkey 或 Redis OSS 命令。以下是一些示例命令及其 Valkey 或 Redis OSS 响应。
```
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
get b // Get value for key "b" results in miss
(nil)
set b "Good-bye" EX 5 // Set key "b" with a string value and a 5 second expiration
get b
"Good-bye"
// wait 5 seconds
get b
(nil) // key has expired, nothing returned
quit // Exit from valkey-cli
```
要连接到具有安全套接字层 (SSL) 加密（启用了传输中加密）的节点或集群，请参阅[ElastiCache 传输中加密 (TLS)](in-transit-encryption.md)。
## 连接到 Memcached 节点
在尝试与 Memcached 集群连接之前，您必须拥有适用于这些节点的终端节点。要找到终端节点，请参阅：
+ [查找集群的端点（控制台）（Memcached）](Endpoints.md#Endpoints.Find.Memcached)
+ [查找端点（AWS CLI）](Endpoints.md#Endpoints.Find.CLI)
+ [查找端点（ElastiCache API）](Endpoints.md#Endpoints.Find.API)
在以下示例中，您使用 *telnet* 实用工具连接到运行 Memcached 的节点。
**注意**
有关 Memcached 以及可用 Memcached 命令的更多信息，请参阅 [Memcached](http://memcached.org/) 网站。
**使用 *telnet* 连接到节点**
1. 使用您选择的连接实用工具连接到 Amazon EC2 实例。
**注意**
有关如何连接到 Amazon EC2 实例的说明，请参阅 [Amazon EC2 入门指南](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/)。
1. 在 Amazon EC2 实例下载并安装 *telnet* 实用工具。在 Amazon EC2 实例的命令提示符处，键入以下命令，然后键入 *y*。
```
sudo yum install telnet
```
此时会显示类似以下内容的输出。
```
Loaded plugins: priorities, security, update-motd, upgrade-helper
Setting up Install Process
Resolving Dependencies
--> Running transaction check
...(output omitted)...
Total download size: 63 k
Installed size: 109 k
Is this ok [y/N]: y
Downloading Packages:
telnet-0.17-47.7.amzn1.x86_64.rpm | 63 kB 00:00
...(output omitted)...
Complete!
```
1. 在 Amazon EC2 实例的命令提示符处，键入以下命令，并使用节点的端点替换此示例中所示的相应节点端点。
```
telnet mycachecluster.eaogs8.0001.usw2.cache.amazonaws.com 11211
```
此时会显示类似以下内容的输出。
```
Trying 128.0.0.1...
Connected to mycachecluster.eaogs8.0001.usw2.cache.amazonaws.com.
Escape character is '^]'.
>
```
1. 运行 Memcached 命令测试连接。
您现已连接到一个节点，可以运行 Memcached 命令了。示例如下：
```
set a 0 0 5 // Set key "a" with no expiration and 5 byte value
hello // Set value as "hello"
STORED
get a // Get value for key "a"
VALUE a 0 5
hello
END
get b // Get value for key "b" results in miss
END
>
```
# 受支持的节点类型
ElastiCache 支持以下节点类型。一般而言，与其上一代类型对应项相比，最新一代类型以更低的成本提供了更多内存和计算能力。
有关每种节点类型的性能细节的更多信息，请参阅 [Amazon EC2 实例类型](https://aws.amazon.com/ec2/instance-types/)。
**注意**
Amazon ElastiCache 正在将 T2 实例过渡到上一代状态。您将无法再使用 T2 实例创建新 ElastiCache 集群或购买新的 T2 预留节点。对现有的 T2 集群或预留没有影响。我们建议升级到较新的实例类型，例如 T3 或 T4g 实例，以获得更好的性能和成本效益。
**注意**
AWS亚太地区（泰国）和墨西哥（中部）地区支持以下实例类型：
**m7g/r7g：**large、xl、2xl、4xl、8xl、12xl 和 16xl。
**t3/t4g：**micro、small 和 medium。
有关要使用的节点大小的信息，请参阅 [选择节点大小](CacheNodes.SelectSize.md)。
**Topics**
+ [最新一代（Memcached）](#CacheNodes.CurrentGen-Memcached)
+ [最新一代（Valkey 或 Redis OSS）](#CacheNodes.CurrentGen)
+ [AWS区域支持的节点类型](#CacheNodes.SupportedTypesByRegion)
+ [可突增性能实例](#CacheNodes.Burstable)
+ [相关信息](#CacheNodes.RelatedInfo)
## 最新一代（Memcached）
下表显示了使用网络 I/O 积分机制突增超出其基准带宽的实例类型的基准带宽和突发带宽。
**注意**
具有可突发网络性能的实例类型使用网络 I/O 积分机制，以尽最大努力突破其基准带宽。
**一般性问题**
| 实例类型 | 支持的最低 Memcached 版本 | 基准带宽（Gbps） | 突增带宽（Gbps） |
| --- | --- | --- | --- |
| cache.m7g.large | | 0.937 | 12.5 |
| cache.m7g.xlarge | | 1.876 | 12.5 |
| cache.m7g.2xlarge | | 3.75 | 15 |
| cache.m7g.4xlarge | | 7.5 | 15 |
| cache.m7g.8xlarge | | 15 | 不适用 |
| cache.m7g.12xlarge | | 22.5 | 不适用 |
| cache.m7g.16xlarge | | 30 | 不适用 |
| cache.m6g.large | 1.5.16 | 0.75 | 10.0 |
| cache.m6g.xlarge | 1.5.16 | 1.25 | 10.0 |
| cache.m6g.2xlarge | 1.5.16 | 2.5 | 10.0 |
| cache.m6g.4xlarge | 1.5.16 | 5.0 | 10.0 |
| cache.m6g.8xlarge | 1.5.16 | 12 | 不适用 |
| cache.m6g.12xlarge | 1.5.16 | 20 | 不适用 |
| cache.m6g.16xlarge | 1.5.16 | 25 | 不适用 |
| cache.m5.large | 1.5.16 | 0.75 | 10.0 |
| cache.m5.xlarge | 1.5.16 | 1.25 | 10.0 |
| cache.m5.2xlarge | 1.5.16 | 2.5 | 10.0 |
| cache.m5.4xlarge | 1.5.16 | 5.0 | 10.0 |
| cache.m5.12xlarge | 1.5.16 | 不适用 | 不适用 |
| cache.m5.24xlarge | 1.5.16 | 不适用 | 不适用 |
| cache.m4.large | 1.5.16 | 0.45 | 1.2 |
| cache.m4.xlarge | 1.5.16 | 0.75 | 2.8 |
| cache.m4.2xlarge | 1.5.16 | 1.0 | 10.0 |
| cache.m4.4xlarge | 1.5.16 | 2.0 | 10.0 |
| cache.m4.10xlarge | 1.5.16 | 5.0 | 10.0 |
| cache.t4g.micro | 1.5.16 | 0.064 | 5.0 |
| cache.t4g.small | 1.5.16 | 0.128 | 5.0 |
| cache.t4g.medium | 1.5.16 | 0.256 | 5.0 |
| cache.t3.micro | 1.5.16 | 0.064 | 5.0 |
| cache.t3.small | 1.5.16 | 0.128 | 5.0 |
| cache.t3.medium | 1.5.16 | 0.256 | 5.0 |
| cache.t2.micro | 1.5.16 | 0.064 | 1.024 |
| cache.t2.small | 1.5.16 | 0.128 | 1.024 |
| cache.t2.medium | 1.5.16 | 0.256 | 1.024 |
**针对 Memcached 进行了优化的内存**
| 实例类型 | 支持的最低版本 | 基准带宽（Gbps） | 突增带宽（Gbps） |
| --- | --- | --- | --- |
| cache.r7g.large | | 0.937 | 12.5 |
| cache.r7g.xlarge | | 1.876 | 12.5 |
| cache.r7g.2xlarge | | 3.75 | 15 |
| cache.r7g.4xlarge | | 7.5 | 15 |
| cache.r7g.8xlarge | | 15 | 不适用 |
| cache.r7g.12xlarge | | 22.5 | 不适用 |
| cache.r7g.16xlarge | | 30 | 不适用 |
| cache.r6g.large | 1.5.16 | 0.75 | 10.0 |
| cache.r6g.xlarge | 1.5.16 | 1.25 | 10.0 |
| cache.r6g.2xlarge | 1.5.16 | 2.5 | 10.0 |
| cache.r6g.4xlarge | 1.5.16 | 5.0 | 10.0 |
| cache.r6g.8xlarge | 1.5.16 | 12 | 不适用 |
| cache.r6g.12xlarge | 1.5.16 | 20 | 不适用 |
| cache.r6g.16xlarge | 1.5.16 | 25 | 不适用 |
| cache.r5.large | 1.5.16 | 0.75 | 10.0 |
| cache.r5.xlarge | 1.5.16 | 1.25 | 10.0 |
| cache.r5.2xlarge | 1.5.16 | 2.5 | 10.0 |
| cache.r5.4xlarge | 1.5.16 | 5.0 | 10.0 |
| cache.r5.12xlarge | 1.5.16 | 20 | 不适用 |
| cache.r5.24xlarge | 1.5.16 | 25 | 不适用 |
| cache.r4.large | 1.5.16 | 0.75 | 10.0 |
| cache.r4.xlarge | 1.5.16 | 1.25 | 10.0 |
| cache.r4.2xlarge | 1.5.16 | 2.5 | 10.0 |
| cache.r4.4xlarge | 1.5.16 | 5.0 | 10.0 |
| cache.r4.8xlarge | 1.5.16 | 12 | 不适用 |
| cache.r4.16xlarge | 1.5.16 | 25 | 不适用 |
**针对 Memcached 进行了优化的网络**
| 实例类型 | 支持的最低版本 | 基准带宽（Gbps） | 突增带宽（Gbps） |
| --- | --- | --- | --- |
| cache.c7gn.large | 1.6.6 | 6.25 | 30 |
| cache.c7gn.xlarge | 1.6.6 | 12.5 | 40 |
| cache.c7gn.2xlarge | 1.6.6 | 25 | 50 |
| cache.c7gn.4xlarge | 1.6.6 | 50 | 不适用 |
| cache.c7gn.8xlarge | 1.6.6 | 100 | 不适用 |
| cache.c7gn.12xlarge | 1.6.6 | 150 | 不适用 |
| cache.c7gn.16xlarge | 1.6.6 | 200 | 不适用 |
## 最新一代（Valkey 或 Redis OSS）
有关上一代的更多信息，请参阅[上一代节点](https://aws.amazon.com/elasticache/previous-generation/)。
**注意**
具有可突发网络性能的实例类型使用网络 I/O 积分机制，以尽最大努力突破其基准带宽。
**一般性问题**
| 实例类型 | 支持的最低 Redis OSS 版本 | I/O 使用 Redis OSS 5.0.6\$1 进行了增强 | TLS 分载（Redis OSS 6.2.5\$1） | 使用 Redis OSS 7.0. I/O 4\$1 增强多路复用 | 基准带宽（Gbps） | 突增带宽（Gbps） |
| --- | --- | --- | --- | --- | --- | --- |
| cache.m7g.large | 6.2 | N | N | N | 0.937 | 12.5 |
| cache.m7g.xlarge | 6.2 | Y | Y | Y | 1.876 | 12.5 |
| cache.m7g.2xlarge | 6.2 | Y | Y | Y | 3.75 | 15 |
| cache.m7g.4xlarge | 6.2 | Y | Y | Y | 7.5 | 15 |
| cache.m7g.8xlarge | 6.2 | Y | Y | Y | 15 | 不适用 |
| cache.m7g.12xlarge | 6.2 | Y | Y | Y | 22.5 | 不适用 |
| cache.m7g.16xlarge | 6.2 | Y | Y | Y | 30 | 不适用 |
| cache.m6g.large | 5.0.6 | N | N | N | 0.75 | 10.0 |
| cache.m6g.xlarge | 5.0.6 | Y | Y | Y | 1.25 | 10.0 |
| cache.m6g.2xlarge | 5.0.6 | Y | Y | Y | 2.5 | 10.0 |
| cache.m6g.4xlarge | 5.0.6 | Y | Y | Y | 5.0 | 10.0 |
| cache.m6g.8xlarge | 5.0.6 | Y | Y | Y | 12 | 不适用 |
| cache.m6g.12xlarge | 5.0.6 | Y | Y | Y | 20 | 不适用 |
| cache.m6g.16xlarge | 5.0.6 | Y | Y | Y | 25 | 不适用 |
| cache.m5.large | 3.2.4 | N | N | N | 0.75 | 10.0 |
| cache.m5.xlarge | 3.2.4 | Y | N | N | 1.25 | 10.0 |
| cache.m5.2xlarge | 3.2.4 | Y | Y | Y | 2.5 | 10.0 |
| cache.m5.4xlarge | 3.2.4 | Y | Y | Y | 5.0 | 10.0 |
| cache.m5.12xlarge | 3.2.4 | Y | Y | Y | 12 | 不适用 |
| cache.m5.24xlarge | 3.2.4 | Y | Y | Y | 25 | 不适用 |
| cache.m4.large | 3.2.4 | N | N | N | 0.45 | 1.2 |
| cache.m4.xlarge | 3.2.4 | Y | N | N | 0.75 | 2.8 |
| cache.m4.2xlarge | 3.2.4 | Y | Y | Y | 1.0 | 10.0 |
| cache.m4.4xlarge | 3.2.4 | Y | Y | Y | 2.0 | 10.0 |
| cache.m4.10xlarge | 3.2.4 | Y | Y | Y | 5.0 | 10.0 |
| cache.t4g.micro | 3.2.4 | N | N | N | 0.064 | 5.0 |
| cache.t4g.small | 5.0.6 | N | N | N | 0.128 | 5.0 |
| cache.t4g.medium | 5.0.6 | N | N | N | 0.256 | 5.0 |
| cache.t3.micro | 3.2.4 | N | N | N | 0.064 | 5.0 |
| cache.t3.small | 3.2.4 | N | N | N | 0.128 | 5.0 |
| cache.t3.medium | 3.2.4 | N | N | N | 0.256 | 5.0 |
| cache.t2.micro | 3.2.4 | N | N | N | 0.064 | 1.024 |
| cache.t2.small | 3.2.4 | N | N | N | 0.128 | 1.024 |
| cache.t2.medium | 3.2.4 | N | N | N | 0.256 | 1.024 |
**内存优化**
| 实例类型 | 支持的最低 Redis OSS 版本 | I/O 使用 Redis OSS 5.0.6\$1 进行了增强 | TLS 分载（Redis OSS 6.2.5\$1） | 使用 Redis OSS 7.0. I/O 4\$1 增强多路复用 | 基准带宽（Gbps） | 突增带宽（Gbps） |
| --- | --- | --- | --- | --- | --- | --- |
| cache.r7g.large | 6.2 | N | N | N | 0.937 | 12.5 |
| cache.r7g.xlarge | 6.2 | Y | Y | Y | 1.876 | 12.5 |
| cache.r7g.2xlarge | 6.2 | Y | Y | Y | 3.75 | 15 |
| cache.r7g.4xlarge | 6.2 | Y | Y | Y | 7.5 | 15 |
| cache.r7g.8xlarge | 6.2 | Y | Y | Y | 15 | 不适用 |
| cache.r7g.12xlarge | 6.2 | Y | Y | Y | 22.5 | 不适用 |
| cache.r7g.16xlarge | 6.2 | Y | Y | Y | 30 | 不适用 |
| cache.r6g.large | 5.0.6 | N | N | N | 0.75 | 10.0 |
| cache.r6g.xlarge | 5.0.6 | Y | Y | Y | 1.25 | 10.0 |
| cache.r6g.2xlarge | 5.0.6 | Y | Y | Y | 2.5 | 10.0 |
| cache.r6g.4xlarge | 5.0.6 | Y | Y | Y | 5.0 | 10.0 |
| cache.r6g.8xlarge | 5.0.6 | Y | Y | Y | 12 | 不适用 |
| cache.r6g.12xlarge | 5.0.6 | Y | Y | Y | 20 | 不适用 |
| cache.r6g.16xlarge | 5.0.6 | Y | Y | Y | 25 | 不适用 |
| cache.r5.large | 3.2.4 | N | N | N | 0.75 | 10.0 |
| cache.r5.xlarge | 3.2.4 | Y | N | N | 1.25 | 10.0 |
| cache.r5.2xlarge | 3.2.4 | Y | Y | Y | 2.5 | 10.0 |
| cache.r5.4xlarge | 3.2.4 | Y | Y | Y | 5.0 | 10.0 |
| cache.r5.12xlarge | 3.2.4 | Y | Y | Y | 12 | 不适用 |
| cache.r5.24xlarge | 3.2.4 | Y | Y | Y | 25 | 不适用 |
| cache.r4.large | 3.2.4 | N | N | N | 0.75 | 10.0 |
| cache.r4.xlarge | 3.2.4 | Y | N | N | 1.25 | 10.0 |
| cache.r4.2xlarge | 3.2.4 | Y | Y | Y | 2.5 | 10.0 |
| cache.r4.4xlarge | 3.2.4 | Y | Y | Y | 5.0 | 10.0 |
| cache.r4.8xlarge | 3.2.4 | Y | Y | Y | 12 | 不适用 |
| cache.r4.16xlarge | 3.2.4 | Y | Y | Y | 25 | 不适用 |
**利用数据分层功能优化内存**
| 实例类型 | 支持的最低 Redis OSS 版本 | I/O 使用 Redis OSS 5.0.6\$1 进行了增强 | TLS 分载（Redis OSS 6.2.5\$1） | 使用 Redis OSS 7.0. I/O 4\$1 增强多路复用 | 基准带宽（Gbps） | 突增带宽（Gbps） |
| --- | --- | --- | --- | --- | --- | --- |
| cache.r6gd.xlarge | 6.2.0 | Y | N | N | 1.25 | 10 |
| cache.r6gd.2xlarge | 6.2.0 | Y | Y | Y | 2.5 | 10 |
| cache.r6gd.4xlarge | 6.2.0 | Y | Y | Y | 5.0 | 10 |
| cache.r6gd.8xlarge | 6.2.0 | Y | Y | Y | 12 | 不适用 |
| cache.r6gd.12xlarge | 6.2.0 | Y | Y | Y | 20 | 不适用 |
| cache.r6gd.16xlarge | 6.2.0 | Y | Y | Y | 25 | 不适用 |
**网络优化**
| 实例类型 | 支持的最低 Redis OSS 版本 | I/O 使用 Redis OSS 5.0.6\$1 进行了增强 | TLS 分载（Redis OSS 6.2.5\$1） | 使用 Redis OSS 7.0. I/O 4\$1 增强多路复用 | 基准带宽（Gbps） | 突增带宽（Gbps） |
| --- | --- | --- | --- | --- | --- | --- |
| cache.c7gn.large | 6.2 | N | N | N | 6.25 | 30 |
| cache.c7gn.xlarge | 6.2 | Y | Y | Y | 12.5 | 40 |
| cache.c7gn.2xlarge | 6.2 | Y | Y | Y | 25 | 50 |
| cache.c7gn.4xlarge | 6.2 | Y | Y | Y | 50 | 不适用 |
| cache.c7gn.8xlarge | 6.2 | Y | Y | Y | 100 | 不适用 |
| cache.c7gn.12xlarge | 6.2 | Y | Y | Y | 150 | 不适用 |
| cache.c7gn.16xlarge | 6.2 | Y | Y | Y | 200 | 不适用 |
## AWS区域支持的节点类型
支持的节点类型可能因AWS地区而异。有关更多详情，请参阅 [Amazon ElastiCache 定价](https://aws.amazon.com/elasticache/pricing/)。
## 可突增性能实例
您可以在亚马逊上启动通用可突发性 T4G、T3-Standard 和 T2-Standard 缓存节点。 ElastiCache这些节点提供基准水平的 CPU 性能，并能随时突增 CPU 使用量，直至累积的积分耗尽。一个 *CPU 积分*提供一个完整 CPU 核心在一分钟内的性能。
Amazon ElastiCache 的 T4g、T3 和 T2 节点配置为标准节点，适用于平均 CPU 利用率一直低于实例基准性能的工作负载。为了突增到基准以上，节点会花费在其 CPU 积分余额中累积的积分。如果节点用完了累积的积分，则性能会逐步减低至基准性能水平。这种逐步减低的过程可确保在耗尽了累积的积分余额时，节点不会出现突然的性能下跌。*有关更多信息，请参阅 *Amazon EC2 用户指南*中的 [CPU 积分和突发性能实例的基准](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-credits-baseline-concepts.html)性能。*
下表列出了可突增性能节点类型以及每小时赚取 CPU 积分的速率。它还显示了节点可以累积的最大 CPU 积分数和CPUs 每个节点的 v 数。此外，它以一个完整核心百分比的形式提供基准性能水平（使用单个 vCPU）。
| 节点类型 | 每小时获得的 CPU 积分 | 可累积获得的最大积分数\$1 | v CPUs | 每个 vCPU 的基准性能 | 内存（GiB） | 网络性能 |
| --- | --- | --- | --- | --- | --- | --- |
| t4g.micro | 12 | 288 | 2 | 10% | 0.5 | 高达 5Gb |
| t4g.small | 24 | 576 | 2 | 20% | 1.37 | 高达 5Gb |
| t4g.medium | 24 | 576 | 2 | 20% | 3.09 | 高达 5Gb |
| t3.micro | 12 | 288 | 2 | 10% | 0.5 | 高达 5Gb |
| t3.small | 24 | 576 | 2 | 20% | 1.37 | 高达 5Gb |
| t3.medium | 24 | 576 | 2 | 20% | 3.09 | 高达 5Gb |
| t2.micro | 6 | 144 | 1 | 10% | 0.5 | 低到中 |
| t2.small | 12 | 288 | 1 | 20% | 1.55 | 低到中 |
| t2.medium | 24 | 576 | 2 | 20% | 3.22 | 低到中 |
\$1 可累积的积分数等于可在 24 小时周期内获得的积分数。
\$1\$1 下表列出了每个 vCPU 的基准性能。一些节点大小具有多个 vCPU。对于这些，通过将 vCPU 百分比乘以 v 来计算节点的基准 CPU 利用率。CPUs
以下 CPU 积分指标对 T3 和 T4 可突增性能实例可用：
**注意**
这些指标对具爆发能力的 T2 实例不可用。
+ `CPUCreditUsage`
+ `CPUCreditBalance`
有关这些指标的更多信息，请参阅 [CPU 积分指标](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/viewing_metrics_with_cloudwatch.html#cpu-credit-metrics)。
此外，请注意以下细节：
+ 默认情况下，所有最新一代节点类型在基于 Amazon VPC 的虚拟私有云（VPC）中创建。
+ T2 实例不支持 Redis OSS 仅附加文件（AOF）。Redis OSS 版本 2.8.22 及更高版本不支持 Redis OSS 配置变量 `appendonly` 和 `appendfsync`。
## 相关信息
+ [Amazon ElastiCache 产品功能和详情](https://aws.amazon.com/elasticache/details)
+ [Memcached 节点类型特定参数](ParameterGroups.Engine.md#ParameterGroups.Memcached)
+ [Valkey 和 Redis OSS 参数](ParameterGroups.Engine.md#ParameterGroups.Redis)
+ [传输中加密（TLS）](in-transit-encryption.md)
# 重启节点
一些更改需要重启 Valkey、Memcached 或 Redis OSS 集群才能应用。例如，对于某些参数，对参数组中参数值的更改仅在重启后才会应用。
**Topics**
+ [重启 Redis OSS 节点（仅限已禁用集群模式）](#nodes.rebooting.redis)
+ [重启 Memcached 集群](#Clusters.Rebooting)
## 重启 Redis OSS 节点（仅限已禁用集群模式）
对于 Valkey 或 Redis OSS（已禁用集群模式）集群，参数组中的参数仅在重启后应用：
+ activerehashing
+ 数据库
Redis 节点只能通过 ElastiCache 控制台更新。一次只能重启单个节点。要重启多个节点，您必须为每个节点重复此过程。
**Valkey 或 Redis OSS（已启用集群模式）参数更改**
如果要更改 Valkey 或 Redis OSS（已启用集群模式）集群上的以下参数，请按照随后的步骤操作。
activerehashing
数据库
创建集群的手动备份。请参阅[进行手动备份](backups-manual.md)。
删除 Valkey 或 Redis OSS（已启用集群模式）集群。请参阅[删除中的集群 ElastiCache](Clusters.Delete.md)。
使用修改的参数组和备份还原集群，以便为新集群创建种子。请参阅[从备份还原到新缓存](backups-restoring.md)。
更改其他参数不需要执行此操作。
### 使用 AWS 管理控制台
可使用 ElastiCache 控制台重启节点。
**重启节点（控制台）**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台 ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/))。
1. 从右上角的列表中，选择适用的 AWS 区域。
1. 在左侧导航窗格中，选择 **Redis OSS**。
此时会显示一个正在运行 Redis OSS 的集群的列表。
1. 选择 **Cluster Name（集群名称）**下的集群。
1. 在 **Node name（节点名称）**下，选择要重启的节点旁边的单选按钮。
1. 选择 **Actions（操作）**，然后选择 **Reboot node（重启节点）**。
要重启多个节点，请对要重启的每个节点重复步骤 2 到步骤 5。在重启另一个节点之前，您无需等待一个节点完成重启。
## 重启 Memcached 集群
当您重启 Memcached 集群时，集群将刷新其所有数据并重新启动其引擎。在此过程中，您无法访问集群。由于集群已刷新其所有数据，因此当集群再次可用时，将从空集群开始。
您可以使用 ElastiCache 控制台、AWS CLI 或 ElastiCache API 重启集群。无论您是使用 ElastiCache 控制台、AWS CLI 还是 ElastiCache API，都只能发起对单个集群的重启。要重启多个集群，您必须对过程或操作进行迭代。
### 使用 AWS 管理控制台
您可以使用 ElastiCache 控制台重启集群。
**重启一个集群（控制台）**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台 ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/))。
1. 从右上角的列表中，选择您感兴趣的 AWS 区域。
1. 在导航窗格中，选择在您要重启的集群上运行的引擎。
此时会显示运行所选引擎的集群的列表。
1. 通过选中集群名称左侧的框来选择要重启的集群。
**重启**按钮处于活动状态。
如果您选择多个集群，则**重启**按钮不可用。
1. 选择**重启**。
此时会显示重启集群确认屏幕。
1. 要重启集群，请选择 **Reboot**。集群的状态将变为 *rebooting cluster nodes (正在重启集群节点)*。
要不重启集群，请选择 **Cancel**。
要重启多个集群，请对要重启的每个集群重复步骤 2 到步骤 5。在重启一个集群之前，您无需等待另一个集群完成重启。
要重启特定节点，请选择相应节点，然后选择 **Reboot（重启）**。
### 使用 AWS CLI
要重启集群 (AWS CLI)，请使用 `reboot-cache-cluster` CLI 操作。
要重启集群中的特定节点，请使用 `--cache-node-ids-to-reboot` 列出要重启的特定集群。以下命令重启 *my-cluster* 的节点 0001、0002 和 0004。
对于 Linux、macOS 或 Unix：
```
aws elasticache reboot-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-ids-to-reboot 0001 0002 0004
```
对于 Windows：
```
aws elasticache reboot-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-ids-to-reboot 0001 0002 0004
```
要重启集群中的所有节点，请使用 `--cache-node-ids-to-reboot` 参数并列出该集群的所有节点 ID。有关更多信息，请参阅 [reboot-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/reboot-cache-cluster.html)。
### 使用 ElastiCache API
要使用 ElastiCache API 重启集群，请使用 `RebootCacheCluster` 操作。
要重启集群中的特定节点，请使用 `CacheNodeIdsToReboot` 列出要重启的特定集群。以下命令重启 *my-cluster* 的节点 0001、0002 和 0004。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=RebootCacheCluster
&CacheClusterId=my-cluster
&CacheNodeIdsToReboot.member.1=0001
&CacheNodeIdsToReboot.member.2=0002
&CacheNodeIdsToReboot.member.3=0004
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
要重启集群中的所有节点，请使用 `CacheNodeIdsToReboot` 参数并列出该集群的所有节点 ID。有关更多信息，请参阅 [RebootCacheCluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_RebootCacheCluster.html)。
# 替换节点（Valkey 和 Redis OSS）
Amazon ElastiCache 频繁升级其实例集，并将补丁和升级无缝应用到实例中。但是，我们需要经常重启您的 ElastiCache 节点，以将必需的操作系统更新应用于底层主机。我们需要进行升级来增强安全性、可靠性和操作性能，而应用这些升级就需要进行替换。
您还可以选择在计划节点替换时段之前的任意时间自已管理这些替换。当您自己管理替换时，您的实例将在重启节点时收到操作系统更新，并且您的计划节点替换将被取消。您可能会继续接收指示节点替换将发生的提醒。如果您已手动缓解对于维护的需求，则可以忽略这些提醒。
**注意**
由 Amazon ElastiCache 自动生成的替换缓存节点可能具有不同的 IP 地址。您负责查看应用程序配置，以确保缓存节点与适当的 IP 地址关联。
以下列表标识了在 ElastiCache 计划 Valkey 或 Redis OSS 替换节点时可执行的操作。要加快查找您的场景所需的信息，请从以下菜单中进行选择。
+ [Do nothing](#DoNothing) – 让 Amazon ElastiCache 按计划替换节点。
+ [Change your maintenance window](#ChangeWindow) – 将您的维护时段更改为更适合的时间。
+ Valkey 或 Redis OSS（已启用集群模式）配置
+ [Replace the only node in any Valkey or Redis OSS cluster](#ReplaceStandalone) – 使用备份和还原替换 Valkey 或 Redis OSS 集群中的节点的过程。
+ [Replace a replica node in any Valkey or Redis OSS cluster](#ReplaceReplica) – 在无需集群停机的情况下通过增加和减少只读副本数量来替换任何 Valkey 或 Redis OSS 集群中的只读副本的过程。
+ [Replace any node in a Valkey or Redis OSS (cluster mode enabled) shard](#ReplaceShardNode) – 在无需集群停机的情况下通过横向扩展和横向缩减来替换 Valkey 或 Redis OSS（已启用集群模式）集群中的节点的动态过程。
+ Valkey 或 Redis OSS（已禁用集群模式）配置
+ [Replace the only node in any Valkey or Redis OSS cluster](#ReplaceStandalone) – 使用备份和还原替换 Valkey 或 Redis OSS 集群中的任何节点的过程。
+ [Replace a replica node in any Valkey or Redis OSS cluster](#ReplaceReplica) – 在无需集群停机的情况下通过增加和减少只读副本数量来替换任何 Valkey 或 Redis OSS 集群中的只读副本的过程。
+ [Replace a node in a Valkey or Redis OSS (cluster mode disabled) cluster](#ReplaceStandaloneClassic) – 使用复制替换 Valkey 或 Redis OSS（已禁用集群模式）集群中的节点的过程。
+ [Replace a Valkey or Redis OSS (cluster mode disabled) read-replica](#ReplaceReadReplica) – 手动替换 Valkey 或 Redis OSS（已禁用集群模式）复制组中的只读副本的过程。
+ [Replace a Valkey or Redis OSS (cluster mode disabled) primary node](#ReplacePrimary) – 手动替换 Valkey 或 Redis OSS（已禁用集群模式）复制组中的主节点的过程。
**Valkey 和 Redis OSS 节点替换选项**
+ **不执行任何操作** – 如果您不执行任何操作，则 ElastiCache 将按计划替换节点。
对于启用了自动失效转移的非集群配置，Valkey 7.2 及以上版本和 Redis OSS 5.0.6 及以上版本的集群，将在集群继续保持在线并处理传入的写入请求时完成替换。对于 Redis OSS 4.0.10 或更低版本上启用了自动失效转移的集群，您可能会注意到与 DNS 更新相关的短暂写入中断（长达几秒钟）。
如果节点属于启用了自动失效转移的集群，则 ElastiCache for Valkey 或 ElastiCache for Redis OSS 可在修补、更新和其他与维护相关的节点替换期间提供更高的可用性。
对于设置为使用 ElastiCache for Valkey 或 ElastiCache for Redis OSS 集群客户端的 ElastiCache 集群配置，在集群处理传入的写入请求时，立即完成替换。
对于启用了自动失效转移的非集群配置，Valkey 7.2 及以上版本和 Redis OSS 5.0.6 及以上版本的集群，将在集群继续保持在线并处理传入的写入请求时完成替换。对于 Redis OSS 4.0.10 或更低版本上启用了自动失效转移的集群，您可能会注意到与 DNS 更新相关的短暂写入中断（长达几秒钟）。
如果节点是独立节点，则 Amazon ElastiCache 会首先启动替换节点，然后从现有节点同步。在这段时间内，现有节点不可用于处理服务请求。同步完成后，现有节点将会终止，新节点将取代它。ElastiCache 会尽最大努力在此操作期间保留您的数据。
+ **更改维护时段** – 对于计划的维护事件，您将收到 ElastiCache 发送的电子邮件或通知事件。在这些情况下，如果在计划替换时间之前更改维护时段，则现在将在新时间替换您的节点。有关更多信息，请参阅下列内容：
+ [修改 ElastiCache 集群](Clusters.Modify.md)
+ [修改复制组](Replication.Modify.md)
**注意**
仅当 ElastiCache 通知包括维护时段时，您才可以通过移动维护时段的方式更改替换时段。如果该通知不包括维护时段，您则无法更改替换窗口。
例如，假设现在是 11 月 9 日星期四 15:00，下一个维护时段是 11 月 10 日星期五 17:00。下面是 3 种情况及其结果：
+ 您将维护时段更改为星期五 16:00，这在当前日期和时间之后且在下一个计划维护时段之前。将在 11 月 10 日星期五 16:00 替换节点。
+ 您将维护时段更改为星期六 16:00，这在当前日期和时间之后且在下一个计划维护时段之后。将在 11 月 11 日星期六 16:00 替换节点。
+ 您将维护时段更改为星期三 16:00，这在当前日期和时间之前。将在 11 月 15 日下一个星期三 16:00 替换节点。
有关说明，请参阅[管理 ElastiCache 集群维护](maintenance-window.md)。
+ **替换任何 Valkey 或 Redis OSS 集群中仅有的节点** – 如果集群没有任何只读副本，您可以使用以下过程来替换节点。
**使用备份和还原替换仅有的节点**
1. 创建节点的集群的快照。有关说明，请参阅[进行手动备份](backups-manual.md)。
1. 以快照做种创建新集群。有关说明，请参阅[从备份还原到新缓存](backups-restoring.md)。
1. 删除具有计划替换的节点的集群。有关说明，请参阅[删除中的集群 ElastiCache](Clusters.Delete.md)。
1. 在您的应用程序中，将旧节点的终端节点替换为新节点的终端节点。
+ **替换任何 Valkey 或 Redis OSS 集群中的副本节点** – 要替换副本集群，请增加副本数量。为此，请添加副本，然后通过删除要替换的副本来减少副本计数。此过程是动态的，不会有任何集群停机。
**注意**
如果您的分区或复制组已有五个副本，请反向操作步骤 1 和 2。
**替换任何 Valkey 或 Redis OSS 集群中的副本**
1. 通过将副本添加到分片或复制组来增加副本数量。有关更多信息，请参阅 [增加分区中的副本数量](increase-replica-count.md)。
1. 删除要替换的副本。有关更多信息，请参阅 [减少分区中的副本数量](decrease-replica-count.md)。
1. 更新应用程序中的终端节点。
+ **替换 Valkey 或 Redis OSS（已启用集群模式）分片中的任何节点** – 要在不停机的情况下替换集群中的节点，请使用在线重新分片。首先通过横向扩展来添加分片，然后通过缩减来删除具有要替换的节点的分片。
**替换 Valkey 或 Redis OSS（已启用集群模式）集群中的任何节点**
1. 扩展：添加其配置与具有要替换的节点的现有分片的配置相同的其他分片。有关更多信息，请参阅 [通过在线重新分片功能添加分片](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online-add)。
1. 缩减：删除具有要替换的节点的分区。有关更多信息，请参阅 [通过在线重新分片功能删除分片](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online-remove)。
1. 更新应用程序中的终端节点。
+ **替换 Valkey 或 Redis OSS（已禁用集群模式）集群中的节点** – 如果集群是没有任何只读副本的 Valkey 或 Redis OSS（已禁用集群模式）集群，请使用以下过程来替换节点。
**使用复制替换节点（仅限已禁用集群模式）**
1. 使用计划替换的节点作为主节点向集群添加复制。不要在此集群上启用多可用区。有关说明，请参阅[向没有分片的 Valkey 或 Redis OSS 集群添加复制](Clusters.AddNode.md#AddReplication.CON)。
1. 将一个只读副本添加到该集群。有关说明，请参阅[向 ElastiCache 集群添加节点（控制台）](Clusters.AddNode.md#AddNode.CON)。
1. 将新创建的只读副本提升为主副本。有关说明，请参阅[将 Valkey 或 Redis OSS（已禁用集群模式）复制组的只读副本提升为主节点](Replication.PromoteReplica.md)。
1. 删除计划替换的节点。有关说明，请参阅[从 ElastiCache 集群中移除节点](Clusters.DeleteNode.md)。
1. 在您的应用程序中，将旧节点的终端节点替换为新节点的终端节点。
+ **替换 Valkey 或 Redis OSS（已禁用集群模式）只读副本** – 如果节点是复制组中的只读副本，则替换该节点。
如果您的集群只具有一个副本节点，并且启用了多可用区，则必须禁用多可用区才能删除副本。有关说明，请参阅[修改复制组](Replication.Modify.md)。
**替换 Valkey 或 Redis OSS（已禁用集群模式）只读副本**
1. 删除计划替换的副本。有关说明，请参阅：
+ [减少分区中的副本数量](decrease-replica-count.md)
+ [从 ElastiCache 集群中移除节点](Clusters.DeleteNode.md)
1. 添加一个新副本来替换计划替换的副本。如果您使用的名称与刚删除的副本相同，可以跳过第 3 步。有关说明，请参阅：
+ [增加分区中的副本数量](increase-replica-count.md)
+ [为 Valkey 或 Redis OSS（已禁用集群模式）添加只读副本](Replication.AddReadReplica.md)
1. 在您的应用程序中，将旧副本的终端节点替换为新副本的终端节点。
1. 如果您在开始时禁用了多可用区，现在请重新启用。有关说明，请参阅[启用多可用区](AutoFailover.md#AutoFailover.Enable)。
+ **替换 Valkey 或 Redis OSS（已禁用集群模式）主节点** – 如果节点是主节点，则先将一个只读副本提升为主节点。然后删除以前是主节点的副本。
如果您的集群只具有一个副本，并且启用了多可用区，则必须禁用多可用区才能在步骤 2 中删除副本。有关说明，请参阅[修改复制组](Replication.Modify.md)。
**替换 Valkey 或 Redis OSS（已禁用集群模式）主节点**
1. 将只读副本提升为主集群。有关说明，请参阅[将 Valkey 或 Redis OSS（已禁用集群模式）复制组的只读副本提升为主节点](Replication.PromoteReplica.md)。
1. 删除计划替换的节点（旧的主节点）。有关说明，请参阅[从 ElastiCache 集群中移除节点](Clusters.DeleteNode.md)。
1. 添加一个新副本来替换计划替换的副本。如果您使用的名称与刚删除的节点相同，可以跳过在应用程序中更改终端节点。
有关说明，请参阅[为 Valkey 或 Redis OSS（已禁用集群模式）添加只读副本](Replication.AddReadReplica.md)。
1. 在您的应用程序中，将旧节点的终端节点替换为新节点的终端节点。
1. 如果您在开始时禁用了多可用区，现在请重新启用。有关说明，请参阅[启用多可用区](AutoFailover.md#AutoFailover.Enable)。
# 替换节点（Memcached）
Amazon ElastiCache for Memcached 频繁升级其机群，将补丁和升级无缝地应用于实例。但是，我们需要经常重启您的 ElastiCache for Memcached 节点，以将必需的操作系统更新应用于底层主机。我们需要进行升级来增强安全性、可靠性和操作性能，而应用这些升级就需要进行替换。
您还可以选择在计划节点替换时段之前的任意时间自已管理这些替换。当您自己管理替换时，您的实例将在重启节点时收到操作系统更新，并且您的计划节点替换将被取消。您可能会继续接收指示节点替换将发生的提醒。如果您已手动缓解对于维护的需求，则可以忽略这些提醒。
**注意**
由 Amazon ElastiCache 自动生成的替换缓存节点可能具有不同的 IP 地址。您负责查看应用程序配置，以确保缓存节点与适当的 IP 地址关联。
以下列表标识了在 ElastiCache 计划替换 Memcached 节点时可执行的操作。
+ **不执行任何操作** – 如果您不执行任何操作，则 ElastiCache 将按计划替换节点。在 ElastiCache 自动使用新节点替换节点时，新节点最初是空的。
+ **更改维护时段** – 对于计划的维护事件，您将收到来自 ElastiCache 的电子邮件或通知事件。在这种情况下，如果在计划替换时间之前更改维护时段，则现在将在新时间替换您的节点。有关更多信息，请参阅 [修改 ElastiCache 集群](Clusters.Modify.md)。
**注意**
仅当 ElastiCache 通知包括维护时段时，您才可以通过移动维护时段的方式更改替换时段。如果该通知不包括维护时段，您则无法更改替换窗口。
例如，假设现在是 11 月 9 日星期四 15:00，下一个维护时段是 11 月 10 日星期五 17:00。下面是 3 种情况及其结果：
+ 您将维护时段更改为星期五 16:00，这在当前日期和时间之后且在下一个计划维护时段之前。将在 11 月 10 日星期五 16:00 替换节点。
+ 您将维护时段更改为星期六 16:00，这在当前日期和时间之后且在下一个计划维护时段之后。将在 11 月 11 日星期六 16:00 替换节点。
+ 您将维护时段更改为星期三 16:00，这在当前日期和时间之前。将在 11 月 15 日下一个星期三 16:00 替换节点。
有关说明，请参阅[管理 ElastiCache 集群维护](maintenance-window.md)。
+ **手动替换节点** – 如果您需要在下一维护时段之前替换节点，请手动替换节点。
如果手动替换节点，则会重新分配密钥。此重新分配会导致缓存丢失。
**手动替换 Memcached 节点**
1. 删除计划替换的节点。有关说明，请参阅[从 ElastiCache 集群中移除节点](Clusters.DeleteNode.md)。
1. 向集群添加一个新节点。有关说明，请参阅[向 ElastiCache 集群添加节点](Clusters.AddNode.md)。
1. 如果您未在此集群上使用自动发现，请参阅您的应用程序，并使用新节点的端点替换旧节点的端点的每个实例。
# 预留节点
预留一个或多个 ElastiCache 节点可能是降低成本的一种方法。预留节点需支付预付费用，此费用取决于节点类型和预留时间长短（一年或三年）。
要查看预留节点是否为您的使用案例节省了成本，请首先确定节点大小和所需节点数。然后估计节点的使用情况，并比较使用按需节点的总成本与使用预留节点的总成本。您可以在集群中混合搭配使用预留和按需节点。有关定价信息，请参阅 [Amazon ElastiCache 定价](https://aws.amazon.com/elasticache/pricing/)。
**Topics**
+ [使用预留节点管理成本](#reserved-nodes)
+ [标准预留节点产品](#reserved-nodes-standard)
+ [大小灵活的预留节点](#reserved-nodes-size)
+ [删除预留节点](#reserved-nodes-deleting)
+ [旧式预留节点产品](#reserved-nodes-utilization)
+ [获取有关预留节点产品的信息](#reserved-nodes-offerings)
+ [购买预留节点](#reserved-nodes-purchasing)
+ [获取有关预留节点的信息](#reserved-nodes-describing)
## 使用预留节点管理成本
预留一个或多个节点是一种降低成本的方法。预留节点需支付预付费用，此费用取决于节点类型和预留时间长短（一年或三年）。此费用远低于按需节点产生的每小时使用费。
要查看预留节点是否为您的使用案例节省了成本，请首先确定节点大小和所需节点数。然后估计节点的使用情况，并比较使用按需节点的总成本与使用预留节点的总成本。您可以在集群中混合搭配使用预留和按需节点。有关定价信息，请参阅 [Amazon ElastiCache 定价](https://aws.amazon.com/elasticache/pricing/)。
AWS 区域、节点类型和有效期长度必须在购买时选择，以后不能更改。
您可以使用 AWS 管理控制台、AWS CLI 或 ElastiCache API 列出和购买可用的预留节点产品。
有关预留节点的更多信息，请参阅 [Amazon ElastiCache 预留节点](https://aws.amazon.com/elasticache/reserved-cache-nodes/)。
## 标准预留节点产品
购买 Amazon ElastiCache 中的预留节点实例（RI），即表示您购买了在预留节点实例的持续时间内对某个特定节点实例类型和 AWS 区域享受折扣费率的承诺。要使用 Amazon ElastiCache 预留节点实例，您需要创建新的 ElastiCache 节点实例，就像您为按需实例创建该实例一样。
如果新预留节点实例的规格与您账户的现有预留节点实例匹配，则将按预留节点实例的折扣费率计费。否则，将以按需费率对节点实例进行收费。这些标准 RI 可从 R5 和 M5 实例系列开始提供。
**注意**
接下来讨论的所有产品类型都提供一年期和三年期选择。
**产品类型**
**无预付** RI 提供对预留 ElastiCache 实例的访问，无需预付款。无论使用情况如何，您的*无预付* 预留 ElastiCache 实例都将按照期限内的小时数，采用打折小时费率进行计费。
**部分预付**：RI 需要预付部分预留 ElasticCache 实例费用。期限内剩余的小时数无论使用情况如何，都将按照打折小时费率计费。此选项替换了以前的*高使用率* 选项（将在下一部分中说明）。
**预付全部费用** – RI 要求在 RI 有效期开始时支付全额费用。无论使用了多少小时数，剩余有效期内不会再产生其他任何费用。
## 大小灵活的预留节点
所有预留节点的大小都很灵活。购买预留节点时，您需要指定节点类型，例如 cache.r6g.xlarge。有关节点类型的更多信息，请参阅 [Amazon ElastiCache 定价](https://aws.amazon.com/elasticache/pricing/ )。
如果您具有节点，则需要将其扩展为更大的容量，预留节点将自动应用于扩展的节点。即，同一节点系列中任何大小的使用率将自动应用预留节点。大小灵活的预留节点可供具有相同 AWS 区域的节点使用。大小灵活的预留节点只能在其节点系列中横向缩减。例如，cache.r6g.xlarge 的预留节点可以应用于 cache.r6g.2xlarge，但不能应用于 cache.r6gd.large，因为 cache.r6g 和 cache.r6gd 属于不同的节点系列。
大小灵活性意味着您可以在相同节点系列的配置之间自由移动。例如，您可以从同一 AWS 区域中的 r6g.xlarge 预留节点（8 个标准化单位）移动到两个 r6g.large 保留节点（8 个标准化单位）（2\$14 = 8 个标准化单位），无任何附加成本。
### 将节点从 Redis OSS 升级到 Valkey
随着 Valkey 在 ElastiCache 中的推出，您现在可以将 Redis OSS 预留节点折扣应用于 Valkey 缓存引擎。您可以从 Redis OSS 升级到 Valkey，同时仍可从现有合同和预留中受益。除了可以在缓存节点系列和引擎中应用这些优势外，您甚至可以获得更多增量价值。Valkey 的定价比 Redis OSS 优惠 20%，而且由于预留节点的灵活性，您可以使用 Redis OSS 预留节点来覆盖 20% 以上运行的 Valkey 节点。
为了计算折扣率，每个 ElastiCache 节点和引擎组合都有一个以单位衡量的标准化系数。预留节点单位可应用于给定引擎的预留节点实例系列中的任何正在运行的节点。此外，Redis OSS 预留节点还可以跨引擎应用，以覆盖正在运行的 Valkey 节点。Valkey 的定价相对于 Redis OSS 和 Memcached 有一定折扣，因此其特定实例类型的单位较低，这使得 Redis OSS 预留节点能够覆盖更多 Valkey 节点。
举个例子，假设您为 Redis OSS 引擎购买了一个 cache.r7g.4xlarge 预留节点（32 个单位），并且正在运行一个 cache.r7g.4xlarge Redis OSS 节点（32 个单位）。如果您将该节点升级到 Valkey，则正在运行的节点的标准化系数将降至 25.6 个单位，而您现有的预留节点将为您提供额外 6.4 个单位，用于区域内 cache.r7g 系列中任何其他正在运行的 Valkey 或 Redis OSS 节点。您可以用它来覆盖账户中另一个 cache.r7g.4xlarge Valkey 节点的 25%（25.6 个单位），或者一个 cache.r7g.xlarge Valkey 节点的 100%（6.4 个单位）。
### 使用标准化单位比较使用情况
您可以使用标准化单位比较不同预留节点大小的使用情况。例如，在两个 cache.r6g.4xlarge 节点上使用一小时相当于在一个 cache.r6g.large 节点上使用 16 个小时。下表显示了每个节点大小的标准化单位数：
****
| 节点大小 | 标准化单位与 Redis OSS 或 Memcached | 标准化单位与 Valkey |
| --- | --- | --- |
| micro | 0.5 | 0.4 |
| small | 1 | 8. |
| medium | 2 | 1.6 |
| large | 4 | 3.2 |
| xlarge | 8 | 6.4 |
| 2xlarge | 16 | 12.8 |
| 4xlarge | 32 | 25.6 |
| 6xlarge | 48 | 38.4 |
| 8xlarge | 64 | 51.2 |
| 10xlarge | 80 | 64 |
| 12xlarge | 96 | 76.8 |
| 16xlarge | 128 | 102.4 |
| 24xlarge | 192 | 153.6 |
例如，您购买了 cache.r6gd.xlarge 预留节点，并且您的账户在同一 AWS 区域中具有两个运行的 cache.r6gd.large 预留节点。在这种情况下，账单优惠将完全应用于两个节点。
![\[Region containing a cache.r6gd.xlarge reserved node with two cache.r6gd.large nodes inside.\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ri1.png)
或者，如果您的账户在同一 AWS 区域中具有一个运行的 cache.r6gd.2xlarge 实例，则账单优惠应用于 50% 的预留节点使用量。
![\[Diagram showing a cache.r6gd.xlarge reserved node region containing a cache.r6gd.2xlarge instance.\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ri2.png)
## 删除预留节点
预留节点具有一年或三年的使用期限。您无法取消预留节点。不过，您可以删除预留节点折扣涵盖的节点。删除预留节点折扣涵盖的节点的过程与删除任何其他节点相同。
如果删除了预留节点折扣涵盖的节点，您可以启动另一个具有兼容规格的节点。在这种情况下，您可以在预留期限（一年或三年）内继续享受折扣费率。
## 旧式预留节点产品
旧式节点预留有三个级别：高利用率、中等利用率和低利用率。节点可在任意利用率级别预留一或三年。节点类型、利用率级别和预留期限将影响总成本。在购买预留节点之前，请通过比较各种模型确认预留节点是否可节省您的业务成本。
在一个利用率级别或期限购买的节点无法转换为不同的利用率级别或期限。
**利用率级别**
*高利用率预留节点* 可支持具备一致基准容量的工作负载或者运行稳定的工作负载。高利用率预留节点需要高预付款，但是如果您计划在 79% 以上的预留节点期内运行，则可最大程度地节省成本 (最多可达按需价格的 70%)。要使用高利用率预留节点，首先需要支付一次性费用。然后，不论节点是否运行，在有效期内以较低的小时费用计费。
如果计划使用预留节点的时间较多，但是希望支付较低的一次性费用或希望在关闭节点时停止计费，*中等利用率预留节点*是最佳选择。如果计划在 40% 以上的预留节点期限内运行，中等利用率预留节点是更加符合成本效益的选择。此选项能节省按需定价 64% 以上的费用。使用中等利用率预留节点，支付的一次性费用比低利用率预留节点略高，在节点运行时适用较低的小时使用费率。
*低利用率预留节点* 适合每天只运行几小时或者每周只运行几天的周期性工作负载。要使用低利用率预留节点，首先需要支付一次性费用，在节点运行时以小时使用费用折扣价计费。只要节点运行时间超过预留节点有效期的 17%，就可以节省成本。在预留节点的整个有效期内，您可以节省成本，节省成本最多可达按需费用的 56%。
**旧式预留节点产品**
| 提供物 | 预支费用 | 使用费 | 优势 |
| --- | --- | --- | --- |
| 高利用率 | 最高 | 最低小时费用。适用于整个期限，无论是否使用预留节点。 | 如果计划在 3 年期的 79% 以上的时间内运行预留节点，可最大程度降低总体成本。 |
| 中等利用率 | 中 | 对每个节点运行小时适用的小时使用费用。节点未运行时，不产生小时费用。 | 适合于弹性工作负载或者当您预期为中度使用（即超过 3 年期的 40%）。 |
| 低利用率 | 最低 | 对每个节点运行小时适用的小时使用费用。节点未运行时，不产生小时费用。所有产品类型的最高小时费用，但是该费用仅在预留节点运行时适用。 | 如果您计划一直运行节点，则总体成本最高。但是，如果您计划不经常（3 年期的 15% 以上的时间）使用预留节点，则总体成本最低。 |
| 按需使用（无预留节点） | 无 | 最高小时费用。只要节点运行即适用。 | 最高小时成本。 |
有关更多信息，请参阅 [Amazon ElastiCache 定价](https://aws.amazon.com/elasticache/pricing/)。
## 获取有关预留节点产品的信息
在购买预留节点之前，可了解有关可用的预留节点产品的信息。
以下示例演示如何使用 AWS 管理控制台、AWS CLI 和 ElastiCache API 获取有关可用的预留节点产品的定价和信息。
**Topics**
+ [使用 AWS 管理控制台](#reserved-nodes-offerings-console)
+ [使用 AWS CLI](#reserved-nodes-offerings-cli)
+ [使用 ElastiCache API](#reserved-nodes-offerings-api)
### 获取有关预留节点产品的信息（控制台）
要使用 AWS 管理控制台获取有关可用预留集群产品的定价和其他信息，请使用以下过程。
**获取有关可用预留节点产品的信息**
1. 登录 AWS 管理控制台并打开 ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 在导航窗格中，选择 **Reserved Nodes**。
1. 选择 **Purchase Reserved Node**（购买预留节点）。
1. 对于**引擎**，选择 Valkey、Memcached 或 Redis OSS。
1. 要确定可用的产品，请选择以下选项：
+ **节点类型**
+ **租期**
+ **产品类型**
在您做出这些选择后，每节点的费用和您的选择的总成本将显示在 **Reservation details**（预留详细信息）下。
1. 选择 **Cancel** 可避免购买这些节点和产生费用。
### 获取有关预留节点产品的信息 (AWS CLI)
要获取 Valkey 或 Redis OSS 可用预留节点产品的定价和其他信息，请在命令提示符处键入以下命令：
```
1. aws elasticache describe-reserved-cache-nodes-offerings
```
此操作将生成类似于以下内容的输出（JSON 格式）：
```
{
"ReservedCacheNodesOfferingId": "0xxxxxxxx-xxeb-44ex-xx3c-xxxxxxxx072",
"CacheNodeType": "cache.xxx.large",
"Duration": 94608000,
"FixedPrice": XXXX.X,
"UsagePrice": X.X,
"ProductDescription": "redis",
"OfferingType": "All Upfront",
"RecurringCharges": [
{
"RecurringChargeAmount": X.X,
"RecurringChargeFrequency": "Hourly"
}
]
},
{
"ReservedCacheNodesOfferingId": "0xxxxxxxx-xxeb-44ex-xx3c-xxxxxxxx072",
"CacheNodeType": "cache.xxx.xlarge",
"Duration": 94608000,
"FixedPrice": XXXX.X,
"UsagePrice": X.X,
"ProductDescription": "redis",
"OfferingType": "Partial Upfront",
"RecurringCharges": [
{
"RecurringChargeAmount": X.XXX,
"RecurringChargeFrequency": "Hourly"
}
]
},
{
"ReservedCacheNodesOfferingId": "0xxxxxxxx-xxeb-44ex-xx3c-xxxxxxxx072",
"CacheNodeType": "cache.xxx.large",
"Duration": 31536000,
"FixedPrice": X.X,
"UsagePrice": X.X,
"ProductDescription": "redis",
"OfferingType": "No Upfront",
"RecurringCharges": [
{
"RecurringChargeAmount": X.XXX,
"RecurringChargeFrequency": "Hourly"
}
]
}
```
要获取 Memcached 可用预留节点产品的定价和其他信息，请在命令提示符处键入以下命令：
```
{
"ReservedCacheNodesOfferingId": "0xxxxxxxx-xxeb-44ex-xx3c-xxxxxxxx072",
"CacheNodeType": "cache.xxx.large",
"Duration": 94608000,
"FixedPrice": XXXX.X,
"UsagePrice": X.X,
"ProductDescription": "memcached",
"OfferingType": "All Upfront",
"RecurringCharges": [
{
"RecurringChargeAmount": X.X,
"RecurringChargeFrequency": "Hourly"
}
]
},
{
"ReservedCacheNodesOfferingId": "0xxxxxxxx-xxeb-44ex-xx3c-xxxxxxxx072",
"CacheNodeType": "cache.xxx.xlarge",
"Duration": 94608000,
"FixedPrice": XXXX.X,
"UsagePrice": X.X,
"ProductDescription": "memcached",
"OfferingType": "Partial Upfront",
"RecurringCharges": [
{
"RecurringChargeAmount": X.XXXX,
"RecurringChargeFrequency": "Hourly"
}
]
},
{
"ReservedCacheNodesOfferingId": "0xxxxxxxx-xxeb-44ex-xx3c-xxxxxxxx072",
"CacheNodeType": "cache.xx.12xlarge",
"Duration": 31536000,
"FixedPrice": X.X,
"UsagePrice": X.X,
"ProductDescription": "memcached",
"OfferingType": "No Upfront",
"RecurringCharges": [
{
"RecurringChargeAmount": X.XXXX,
"RecurringChargeFrequency": "Hourly"
}
]
}
```
有关更多信息，请参阅《AWS CLI 参考》中的 [describe-reserved-cache-nodes-offerings](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-reserved-cache-nodes-offerings.html)。
### 获取有关预留节点产品的信息 (ElastiCache API)
若要获取有关可用预留节点产品的定价和信息，请调用 `DescribeReservedCacheNodesOfferings` 操作。
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReservedCacheNodesOfferings
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
有关更多信息，请参阅《ElastiCache API 参考》中的 [DescribeReservedCacheNodesOfferings](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReservedCacheNodesOfferings.html)。
## 购买预留节点
以下示例演示如何使用 AWS 管理控制台、AWS CLI 和 ElastiCache API 购买预留节点产品。
**重要**
按照本部分中的示例演示操作会在您的 AWS 账户中产生不可取消的费用。
**Topics**
+ [使用 AWS 管理控制台](#reserved-nodes-purchasing-console)
+ [使用 AWS CLI](#reserved-nodes-purchasing-cli)
+ [使用 ElastiCache API](#reserved-nodes-purchasing-api)
### 购买预留节点（控制台）
此示例演示如何购买预留节点 ID 为 *myreservationID* 的特定预留节点产品 *649fd0c8-cf6d-47a0-bfa6-060f8e75e95f*。
以下过程使用 AWS 管理控制台通过提供 ID 来购买预留节点产品。
**购买预留节点**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 在导航列表中，选择 **Reserved Nodes**（预留节点）链接。
1. 选择 **Purchase reserved nodes**（购买预留节点）按钮。
1. 对于**引擎**，选择 Valkey、Memcached 或 Redis OSS。
1. 要确定可用的产品，请选择以下选项：
+ **节点类型**
+ **租期**
+ **产品类型**
+ 一个可选的 **Reserved node ID**（预留节点 ID）
在您做出这些选择后，每节点的费用和您的选择的总成本将显示在 **Reservation details**（预留详细信息）下。
1. 选择 **Purchase (购买)**。
### 购买预留节点 (AWS CLI)
以下示例演示如何购买预留节点 ID 为 *myreservationID* 的特定预留集群产品 *649fd0c8-cf6d-47a0-bfa6-060f8e75e95f*。
在命令提示符处输入以下命令：
对于 Linux、macOS 或 Unix：
```
1. aws elasticache purchase-reserved-cache-nodes-offering \
2. --reserved-cache-nodes-offering-id 649fd0c8-cf6d-47a0-bfa6-060f8e75e95f \
3. --reserved-cache-node-id myreservationID
```
对于 Windows：
```
1. aws elasticache purchase-reserved-cache-nodes-offering ^
2. --reserved-cache-nodes-offering-id 649fd0c8-cf6d-47a0-bfa6-060f8e75e95f ^
3. --reserved-cache-node-id myreservationID
```
该命令返回的输出类似于下方内容：
```
1. RESERVATION ReservationId Class Start Time Duration Fixed Price Usage Price Count State Description Offering Type
2. RESERVATION myreservationid cache.xx.small 2013-12-19T00:30:23.247Z 1y XXX.XX USD X.XXX USD 1 payment-pending memcached Medium Utilization
```
有关更多信息，请参阅《AWS CLI 参考》中的 [purchase-reserved-cache-nodes-offering](https://docs.aws.amazon.com/cli/latest/reference/elasticache/purchase-reserved-cache-nodes-offering.html)。
### 购买预留节点 (ElastiCache API)
以下示例演示如何购买预留集群 ID 为 *myreservationID* 的特定预留节点产品 *649fd0c8-cf6d-47a0-bfa6-060f8e75e95f*。
按照以下参数调用 `PurchaseReservedCacheNodesOffering` 操作：
+ `ReservedCacheNodesOfferingId` = `649fd0c8-cf6d-47a0-bfa6-060f8e75e95f`
+ `ReservedCacheNodeID` = `myreservationID`
+ `CacheNodeCount` = `1`
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=PurchaseReservedCacheNodesOffering
&ReservedCacheNodesOfferingId=649fd0c8-cf6d-47a0-bfa6-060f8e75e95f
&ReservedCacheNodeID=myreservationID
&CacheNodeCount=1
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
有关更多信息，请参阅《ElastiCache API 参考》中的 [PurchaseReservedCacheNodesOffering](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_PurchaseReservedCacheNodesOffering.html)。
## 获取有关预留节点的信息
您可以使用 AWS 管理控制台、AWS CLI 和 ElastiCache API 获取有关已购买的预留节点的信息。
**Topics**
+ [使用 AWS 管理控制台](#reserved-nodes-describing-console)
+ [使用 AWS CLI](#reserved-nodes-describing-cli)
+ [使用 ElastiCache API](#reserved-nodes-describing-api)
### 获取有关预留节点的信息（控制台）
以下过程介绍如何使用 AWS 管理控制台获取有关您购买的预留节点的信息。
**获取有关已购买的预留节点的信息**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 在导航列表中，选择 **Reserved nodes**（预留节点）链接。
您的账户的预留节点显示在 Reserved nodes（预留节点）列表中。您可选择列表中的任何预留节点，在控制台底部的详细信息窗格中查看有关该预留节点的详细信息。
### 获取有关预留节点的信息 (AWS CLI)
若要获取有关您的 AWS 账户的预留节点的信息，请在命令提示符处键入以下命令：
```
aws elasticache describe-reserved-cache-nodes
```
此操作将生成类似于以下内容的输出（JSON 格式）：
```
{
"ReservedCacheNodeId": "myreservationid",
"ReservedCacheNodesOfferingId": "649fd0c8-cf6d-47a0-bfa6-060f8e75e95f",
"CacheNodeType": "cache.xx.small",
"DataTiering": "disabled",
"Duration": "31536000",
"ProductDescription": "memcached",
"OfferingType": "Medium Utilization",
"MaxRecords": 0
}
```
有关更多信息，请参阅《AWS CLI 参考》中的 [describe-reserved-cache-nodes](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-reserved-cache-nodes.html)。
### 获取有关预留节点的信息 (ElastiCache API)
若要获取有关您的 AWS 账户的预留节点的信息，请调用 `DescribeReservedCacheNodes` 操作。
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReservedCacheNodes
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
有关更多信息，请参阅《ElastiCache API 参考》中的 [DescribeReservedCacheNodes](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReservedCacheNodes.html)。
# 迁移上一代节点
上一代节点是正在逐步停用的节点类型。如果您的现有集群未使用上一代节点类型，则 ElastiCache 不支持创建具有该节点类型的新集群。
由于上一代节点类型的数量有限，当某一节点在集群中运行状况不佳时，我们无法保证成功替换该节点。在这种情况下，您的集群可用性可能会受到负面影响。
我们建议您将集群迁移到新的节点类型，以获得更好的可用性和性能。有关要迁移到的建议节点类型，请参阅[升级途径](https://aws.amazon.com/ec2/previous-generation/)。有关 ElastiCache 中支持的节点类型和上一代节点类型的完整列表，请参阅 [受支持的节点类型](CacheNodes.SupportedTypes.md)。
## 迁移 Valkey 或 Redis OSS 集群上的节点
以下程序介绍了如何使用 ElastiCache 控制台迁移 Valkey 或 Redis OSS 集群节点类型。在此过程中，您的 Valkey 或 Redis OSS 集群将继续处理请求，且停机时间降至最短。根据您的集群配置，您可能会遇到以下停机时间。以下是估计值，可能因您的具体配置而有所不同：
+ 已禁用集群模式（单节点）的停机时间可能大约为 60 秒，主要原因是 DNS 传播。
+ 对于运行 Valkey 7.2 及以上版本或 Redis OSS 5.0.6 及以上版本的集群，已禁用集群模式（具有副本节点）的停机时间可能大约为 1 秒钟。所有较低版本的停机时间大约为 10 秒钟。
+ 启用集群模式的停机时间可能大约为 1 秒钟。
**要使用控制台修改 Valkey 或 Redis OSS 集群节点类型：**
1. 登录到控制台并打开 ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/home)）。
1. 在导航窗格中，选择 **Valkey 集群**或 **Redis OSS 集群**。
1. 从集群列表中，选择要迁移的集群。
1. 选择 **Actions**（操作），然后选择 **Modify**（修改）。
1. 从节点类型列表中选择新的节点类型。
1. 如果您要立即执行迁移过程，请选择 **Apply immediately（立即应用）**。如果 **Apply immediately（立即应用）**处于未选中状态，则在此集群的下一维护时段内执行迁移过程。
1. 选择 **Modify**（修改）。如果您在上一步选择了 **Apply immediately**，则集群的状态将变为 **modifying**。当状态变为 **available** 时，即表示修改完成，您可以开始使用新集群。
*要使用 AWS CLI 修改 Valkey 或 Redis OSS 集群节点类型：*
使用 [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html) API，如下所示：
对于 Linux、macOS 或 Unix：
```
aws elasticache modify-replication-group /
--replication-group-id my-replication-group /
--cache-node-type new-node-type /
--apply-immediately
```
对于 Windows：
```
aws elasticache modify-replication-group ^
--replication-group-id my-replication-group ^
--cache-node-type new-node-type ^
--apply-immediately
```
在这种情况下，*new-node-type* 的值是您要迁移到的节点类型。通过传递 `--apply-immediately` 参数，当复制组从 **modifying（正在修改）**变为 **available（可用）**状态时，将立即应用更新。如果 **Apply immediately（立即应用）**处于未选中状态，则在此集群的下一维护时段内执行迁移过程。
**注意**
如果您无法修改带有 `InvalidCacheClusterState` 错误的集群，则需要先删除还原失败的节点。
### 修复或移除 restore-failed-node
以下程序介绍了如何从 Valkey 或 Redis OSS 集群中移除还原失败的节点。要详细了解 ElastiCache 节点如何进入还原失败状态，请参阅[查看 ElastiCache 节点状态](Nodes.viewing.md)。我们建议先移除所有处于还原失败状态的节点，然后将 ElastiCache 集群中剩余的上一代节点迁移到新一代节点类型，最后再重新添加所需数量的节点。
要移除还原失败的节点（控制台）：
1. 登录到控制台并打开 ElastiCache 控制台 ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/home))。
1. 在导航窗格中，选择 **Valkey 集群**或 **Redis OSS 集群**。
1. 从集群列表中，选择要从中移除节点的集群。
1. 从分区列表中，选择要从中移除节点的分区。如果集群的集群模式已禁用，则跳过此步骤。
1. 从节点列表中，选择状态为 `restore-failed` 的节点。
1. 选择 **Actions（操作）**，然后选择 **Delete node（删除节点）**。
从 ElastiCache 集群中移除还原失败的节点后，您现在可以迁移到新一代类型。有关更多信息，请参阅有关[迁移 Valkey 或 Redis OSS 集群上的节点](#CacheNodes.NodeMigration.Redis)的上述内容。
要重新向 ElastiCache 集群添加节点，请参阅[向 ElastiCache 集群添加节点](Clusters.AddNode.md)。
## 迁移 Memcached 集群上的节点
要将 ElastiCache for Memcached 迁移到其他节点类型，您必须创建一个新的集群，该集群始终以空开始，以便您的应用程序可以填充。
**要使用 ElastiCache 控制台迁移 ElastiCache for Memcached 集群节点类型：**
+ 利用新的节点类型创建新集群。有关更多信息，请参阅 [创建 Memcached 集群（控制台）](Clusters.Create-mc.md#Clusters.Create.CON.Memcached)。
+ 在您的应用程序中，将终端节点更新为新集群的终端节点。有关更多信息，请参阅[查找集群的端点（控制台）（Memcached）](Endpoints.md#Endpoints.Find.Memcached)
+ 删除旧的集群。有关更多信息，请参阅 [删除中的集群 ElastiCache](Clusters.Delete.md)。
# 在 ElastiCache 中管理集群
*集群*是一个或多个缓存节点的集合，其中所有节点都运行 Valkey、Memcached 和 Redis OSS 引擎软件的实例。创建集群时，您需要指定所有节点将使用的引擎和版本。
**Valkey 和 Redis OSS 集群**
下图展示了典型的 Valkey 或 Redis OSS 集群。这些集群可在一个分片（API/CLI：节点组）中包含单个节点或最多 6 个节点，单节点 Valkey 或 Redis OSS（已禁用集群模式）集群没有分片，多节点 Valkey 或 Redis OSS（已禁用集群模式）集群有一个分片。Valkey 或 Redis OSS 集群最多可以拥有 500 个分片，并且跨分片对您的数据进行分区。如果引擎为 Valkey 7.2 及更高版本或 Redis OSS 5.0.6 及更高版本，您可以将每个集群的节点或分片限制增至最多 500 个。例如，您可以选择配置一个 500 节点的集群，范围介于 83 个分片（一个主分片和 5 个副本分片）和 500 个分片（一个主分片，无副本分片）之间。确保可提供足够的 IP 地址来满足增长需求。常见的陷阱包括子网组中的子网 CIDR 范围太小，或者子网被其他集群共享和大量使用。有关更多信息，请参阅 [创建子网组](SubnetGroups.Creating.md)。对于低于 5.0.6 的版本，每个集群的限制为 250。
若要请求提高限制，请参阅 [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) 并选择限制类型 **Nodes per cluster per instance type（每个实例类型的每个集群的节点数）**。
如果一个 Valkey 或 Redis OSS 分片中有多个节点，其中一个节点将作为读/写主节点。分片中的所有其他节点均为只读副本。
典型的 Valkey 或 Redis OSS 集群如下所示。
![\[图片：典型的 Valkey 和 Redis OSS 集群\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Redis.png)
**Memcached 集群**
典型的 Memcached 集群如下所示。Memcached 集群包含 1 到 60 个节点，您可以跨这些节点对数据进行水平分区。
![\[图像：典型的 Memcached 集群\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
**Valkey、Memcached 和 Redis OSS 的 ElastiCache 操作**
大多数 ElastiCache 操作在集群级别上执行。可以使用特定数量的节点和一个控制各个节点属性的参数组来设置集群。一个集群中的所有节点都应该是相同的节点类型，具有相同的参数和安全组设置。
每个集群必须有一个集群标识符。集群标识符是用户为集群提供的名称。此标识符指定了一个在与 ElastiCache API 和 AWS CLI 命令互动时的特殊集群。在 AWS 区域中，集群标识符对于该用户必须是唯一的。
ElastiCache 支持多个引擎版本。除非您有特定原因，否则我们建议您使用最新版本。
ElastiCache 集群旨在通过 Amazon EC2 实例进行访问。如果您根据 Amazon VPC 服务在 Virtual Private Cloud (VPC) 中启动集群，可从 AWS 外部进行访问。有关更多信息，请参阅 [从外部访问 ElastiCache 资源AWS](accessing-elasticache.md#access-from-outside-aws)。
有关受支持的版本的列表，请参阅[支持的引擎和版本](VersionManagement.md#supported-engine-versions)、[支持的 Redis OSS 引擎版本](engine-versions.md#supported-engine-versions.redis)和[支持 Mem ElastiCache cached 版本](engine-versions.md#supported-engine-versions-mc)。
# 在中选择网络类型 ElastiCache
ElastiCache 支持 Internet 协议版本 4 IPv4 和 6（和 IPv6），允许您将集群配置为接受：
+ 只有 IPv4 连接，
+ 只有 IPv6 连接，
+ 两者 IPv4 兼而 IPv6 有之（双栈）
IPv6 [在 Nitro 系统上构建的所有实例上都支持使用 Valkey 7.2 及更高版本或 Redis OSS 6.2 及更高版本的工作负载。](https://aws.amazon.com/ec2/nitro/)通过访问 ElastiCache 不收取任何额外费用 IPv6。
**注意**
不支持迁移在 IPV6 /dual-stack 可用之前创建的集群。也不支持在新创建的集群上切换网络类型。
IPv6 [支持在 Nitro 系统上构建的所有实例上使用 Memcached 1.6.6 及更高版本的工作负载。](https://aws.amazon.com/ec2/nitro/)通过访问 ElastiCache 不收取任何额外费用 IPv6。
## 为网络类型配置子网
如果您在 Amazon VPC 中创建集群，则必须指定子网组。 ElastiCache 使用该子网组选择子网和该子网内的 IP 地址以与您的节点关联。 ElastiCache 群集需要一个双堆栈子网 IPv4 并分配给它们 IPv6 的地址才能在双堆栈模式下运行，并且需要一个 IPv6仅限子网才能以-only模式运行。 IPv6
## 使用双堆栈将解为
在启用了集群模式的 Redis OSS 上使用 ElastiCache 时，从应用程序的角度来看，通过配置终端节点连接到所有集群节点与直接连接到单个缓存节点没有什么不同。要实现此目的，集群感知客户端必须参与群集发现过程并请求所有节点的配置信息。Redis 的发现协议仅支持每个节点一个 IP。
当您使用 ElastiCache for Memcached 创建集群并选择双堆栈作为网络类型时，您需要指定 IP 发现类型，即或。 IPv4 IPv6 ElastiCache 会将网络类型和 IP 发现默认为 IPv6，但可以更改。如果您使用 Auto Discovery，则仅将所选 IP 类型的 IP 地址返回给 Memcached 客户端。有关更多信息，请参阅 [自动识别集群（Memcached）中的节点](AutoDiscovery.md)。
为了保持与所有现有客户端的向后兼容性，引入了 IP 发现，允许您选择要在发现协议中通告的 IP 类型（即 IPv4 或 IPv6）。虽然这将 auto discovery 限制为仅有一种 IP 类型，但双堆栈对于启用集群模式的工作负载仍然有利，因为它可以在不停机的情况下从 IPv6 Discovery IP 类型迁移（或回滚）。 IPv4
## 启用 TLS 的双堆栈 ElastiCache 集群
当为 ElastiCache 集群启用 TLS 时，集群发现功能（例如`cluster slots``cluster shards`、和）`cluster nodes`使用 Valkey 或 Redis OSS 以及 `config get cluster` Memcached 时会返回主机名而不是。 IPs然后使用主机名代替 IPs 连接到 ElastiCache 集群并执行 TLS 握手。这意味着客户端不会受到 IP 发现参数的影响。*对于启用 TLS 的集群，IP 发现参数对首选 IP 协议没有影响。*相反，使用的 IP 协议将取决于客户端在解析 DNS 主机名时首选的 IP 协议。
有关在解析 DNS 主机名时如何配置 IP 协议首选项的示例，请参阅[启用 TLS 的双栈 ElastiCache 集群](BestPractices.md#network-type-configuring-tls-enabled-dual-stack)。
## 使用AWS 管理控制台（Valkey 和 Redis OSS）
使用创建集群时AWS 管理控制台，在 “**连接**” 下，选择网络类型 **IPv4**，**IPv6**或者**双堆栈**。如果您要创建 Valkey 或 Redis OSS（已启用集群模式）集群并选择双堆栈，则必须选择**发现 IP 类型**，即或 IPv6 。 IPv4
有关更多信息，请参阅 [创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster)或 [创建 Valkey 或 Redis OSS 集群（已禁用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.Redis)。
使用创建复制组时AWS 管理控制台，请选择网络类型**IPv6**或**双堆栈**。**IPv4**如果选择双堆栈，则必须选择 **Discovery IP 类型**，即 IPv6 或 IPv4。
有关更多信息，请参阅 [从头创建 Valkey 或 Redis OSS（已禁用集群模式）复制组](Replication.CreatingReplGroup.NoExistingCluster.Classic.md)或 [从头开始在 Valkey 或 Redis OSS（已启用集群模式）中创建复制组](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md)。
## 使用AWS 管理控制台(Memcached)
使用创建集群时AWS 管理控制台，在 “**连接**” 下，选择网络类型 **IPv4**，**IPv6**或者**双堆栈**。如果选择双堆栈，则必须选择 **Discovery IP 类型**，即 IPv6 或 IPv4。
有关更多信息，请参阅 [创建 Memcached 集群（控制台）](Clusters.Create-mc.md#Clusters.Create.CON.Memcached)。
## 将 CLI 与 Valkey、Memcached 或 Redis OSS 结合使用。
**Redis OSS**
使用 CLI 创建带有 Valkey 或 Redis OSS 的集群时，您可以使用[create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)命令并指定`NetworkType`和`IPDiscovery`参数：
对于 Linux、macOS 或 Unix：
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine redis \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
对于 Windows：
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine redis ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
使用 CLI 创建禁用集群模式的复制组时，您可以使用[create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)命令并指定`NetworkType`和`IPDiscovery`参数：
对于 Linux、macOS 或 Unix：
```
aws elasticache create-replication-group \
--replication-group-id sample-repl-group \
--replication-group-description "demo cluster with replicas" \
--num-cache-clusters 3 \
--primary-cluster-id redis01 \
--network-type dual_stack \
--ip-discovery ipv4
```
对于 Windows：
```
aws elasticache create-replication-group ^
--replication-group-id sample-repl-group ^
--replication-group-description "demo cluster with replicas" ^
--num-cache-clusters 3 ^
--primary-cluster-id redis01 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
使用 CLI 创建启用了群集模式并用 IPv4 于 IP 发现的复制组时，您可以使用[create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)命令并指定`NetworkType`和`IPDiscovery`参数：
对于 Linux、macOS 或 Unix：
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv4 \
--region us-east-1
```
对于 Windows：
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv4 ^
--region us-east-1
```
使用 CLI 创建启用了群集模式并用 IPv6 于 IP 发现的复制组时，您可以使用[create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)命令并指定`NetworkType`和`IPDiscovery`参数：
对于 Linux、macOS 或 Unix：
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv6 \
--region us-east-1
```
对于 Windows：
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv6 ^
--region us-east-1
```
**Memcached**
使用 CLI 使用 Memcached 创建集群时，您可以使用[create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)命令并指定`NetworkType`和`IPDiscovery`参数：
对于 Linux、macOS 或 Unix：
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine memcached \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
对于 Windows：
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine memcached ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
# 自动识别集群（Memcached）中的节点
对于运行 Memcached 引擎的集群，ElastiCache 支持 *Auto Discovery*，即客户端程序能够自动识别集群中的所有节点，并启动和维护与所有这些节点的连接。
**注意**
为在 Amazon ElastiCache Memcached 上运行的集群添加了自动发现。Auto Discovery 不适用于 Valkey 或 Redis OSS 引擎。
借助 Auto Discovery，您的应用程序无需手动连接至单个缓存节点；相反，您的应用程序连接至一个 Memcached 节点并检索节点列表。通过该列表，应用程序可知道集群中的其余节点并能连接至其中的任一节点。您无需对应用程序中的单个缓存节点端点进行硬编码。
如果您在集群上使用双堆栈网络类型，则 Auto Discovery 将仅返回 IPv4 或 IPv6 地址，具体取决于您选择的地址。有关更多信息，请参阅 [在中选择网络类型 ElastiCache](network-type.md)。
集群中的所有缓存节点都会保留一份与所有其他节点有关的元数据列表。每当在集群中添加节点时或从集群中移除节点时，此类元数据都会进行更新。
**Topics**
+ [使用 Memcached Auto Discovery 功能的好处](AutoDiscovery.Benefits.md)
+ [Auto Discovery 如何发挥作用](AutoDiscovery.HowAutoDiscoveryWorks.md)
+ [使用 Auto Discovery](AutoDiscovery.Using.md)
+ [手动连接至 Memcached 缓存节点](AutoDiscovery.Manual.md)
+ [在 Memcached 客户端库中添加 Auto Discovery](AutoDiscovery.AddingToYourClientLibrary.md)
+ [ElastiCache 具有 auto 发现功能的客户端](Clients.md)
# 使用 Memcached Auto Discovery 功能的好处
使用 Memcached 时，Auto Discovery 可提供下列好处：
+ 当您增加集群中的节点数时，新节点会向配置端点和所有其他节点进行注册。当您从缓存集群中移除节点时，分离的节点会取消注册自己。在这两种情况下，集群中的所有其他节点都会使用最新的缓存节点元数据进行更新。
+ 缓存节点故障会被自动检测到；故障节点会被自动替换。
**注意**
在节点替换完成之前，节点仍将出现故障。
+ 客户端程序只需连接至配置终端节点。之后，Auto Discovery 库会连接至集群中的所有其他节点。
+ 客户端程序每分钟轮询集群一次（如有必要，可调整此时间间隔）。如果对集群配置做出任何更改（例如新添或删除节点），客户端会收到一份更新的元数据列表。然后，客户端会根据需要连接至这些节点或与这些节点断开。
所有 ElastiCache Memcached 集群都启用了自动发现。您无需重启您的任何缓存节点，即可使用此功能。
# Auto Discovery 如何发挥作用
**Topics**
+ [连接至缓存节点](#AutoDiscovery.HowAutoDiscoveryWorks.Connecting)
+ [正常集群操作](#AutoDiscovery.HowAutoDiscoveryWorks.NormalOps)
+ [其他操作](#AutoDiscovery.HowAutoDiscoveryWorks.OtherOps)
本部分介绍了客户端应用程序如何使用 ElastiCache Cluster Client 来管理缓存节点连接，并与缓存中的数据项目互动。
## 连接至缓存节点
从应用程序的角度来看，连接至集群配置终端节点与直接连接至个别缓存节点并无差别。下面的序列图显示了连接至缓存节点的流程。
![\[连接至缓存节点\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/autodiscovery_cluster_membership_refresh-diagram.png)
**连接至缓存节点的流程**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/callouts/1.png) | 应用程序可以解析配置终端节点的 DNS 名称。由于配置终端节点为所有缓存节点保留 CNAME 条目，因此 DNS 名称被定为其中的一个节点；然后，客户端便可连接至这个节点。 |
| ![\[2\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/callouts/2.png) | 客户端需要所有其他节点的配置信息。由于每个节点都为集群中的所有节点保留配置信息，因此任何节点都可以根据请求把配置信息传给客户端。 |
| ![\[3\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/callouts/3.png) | 客户端则可收到当前的缓存节点主机名和 IP 地址列表。随后，它可以连接至集群中的所有其他节点。 |
**注意**
客户端程序每分钟刷新一次缓存节点主机名和 IP 地址列表。如有必要，可以调整这个轮询间隔时间。
## 正常集群操作
当应用程序已连接至所有缓存节点时，ElastiCache Cluster Client 可以确定哪些节点应该存储单个数据项，以及哪些节点稍后应该用来查询此类数据项目。下面的序列图显示了正常集群操作的流程。
![\[正常集群操作\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/autodiscovery_normal_cache_usage-diagram.png)
**正常集群操作的流程**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/callouts/1.png) | 应用程序发出一个 get 请求，旨在获取一个由其密钥识别的特定数据项。 |
| ![\[2\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/callouts/2.png) | 客户端针对密钥采用一种哈希算法，以确定哪一个缓存节点包含数据项。 |
| ![\[3\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/callouts/3.png) | 数据项是从相关节点处请求的。 |
| ![\[4\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/callouts/4.png) | 数据项会返还至应用程序。 |
## 其他操作
在某些情况下，您可能会更改集群的节点。例如，您可以添加附加节点来满足其他需求，或者删除节点以在需求减少期间节省资金。或者，您可能会因某种或另一种节点故障而替换节点。
当集群中发生需要对集群的终端节点进行元数据更新的更改时，将同时对所有节点进行此更改。因此，任何给定节点中的元数据将与集群中的所有其他节点中的元数据保持一致。
在所有这些情况下，元数据在所有节点间始终保持一致，因为将同时为集群中的所有节点更新元数据。您应始终使用配置终端节点来获取集群中各个节点的终端节点。通过使用配置终端节点，可确保您不会从对您“不可见”的节点获取终端节点数据。
### 添加节点
在启动节点的过程中，节点的终端节点不包含在元数据中。一旦该节点可用，就会将它添加到集群的每个节点的元数据中。在此方案中，元数据在所有节点间保持一致，并且您仅在新节点可用后能够与之交互。在节点可用之前，您不会知道该节点，并且您将与集群中的节点进行交互，就好像新节点不存在一样。
### 删除节点
在删除某个节点时，先从元数据中删除该节点的终端节点，然后从集群中删除该节点。在此方案中，所有节点中的元数据保持一致，如果要删除的节点不可用，则任何时候元数据都不会包含该节点的终端节点。在删除节点期间，将不会在元数据中进行报告，您的应用程序仅与其余 n-1 个节点进行交互，就好像该节点不存在一样。
### 替换节点
如果某个节点失败，ElastiCache 将中断该节点并启动替换节点。替换过程需要花费几分钟的时间。在此期间，所有节点中的元数据仍将显示失败节点的终端节点，但任何尝试与该节点进行交互的操作都将失败。因此，您的逻辑应始终包含重试逻辑。
# 使用 Auto Discovery
要开始将自动发现功能与 ElastiCache for Memcached 搭配使用，请按照以下步骤操作：
+ [获取配置端点](#AutoDiscovery.Using.ConfigEndpoint)
+ [下载 ElastiCache Cluster Client](#AutoDiscovery.Using.ClusterClient)
+ [修改应用程序编程](#AutoDiscovery.Using.ModifyApp)
## 获取配置端点
如要连接至某个集群，客户端程序必须知道集群的配置终端节点。请参阅主题[查找集群的端点（控制台）（Memcached）](Endpoints.md#Endpoints.Find.Memcached)。
您也可以使用带有 `aws elasticache describe-cache-clusters` 参数的 `--show-cache-node-info` 命令：
不论您使用什么方法查找集群的终端节点，配置终端节点的地址中始终有 **.cfg**。
**Example 使用适用于 ElastiCache 的 AWS CLI 查找端点**
对于 Linux、macOS 或 Unix：
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
对于 Windows：
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
此操作将生成类似于以下内容的输出（JSON 格式）：
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0001.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1e"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0002.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1a"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "Multiple",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-10-12T21:39:28.001Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "sat:06:00-sat:07:00",
"CacheNodeType": "cache.r3.large"
}
]
}
```
## 下载 ElastiCache Cluster Client
如要利用 Auto Discovery，客户端程序必须使用 *ElastiCache Cluster Client*。ElastiCache Cluster Client 可用于 Java、PHP 和 .NET，其中包含适用于发现和连接至您的所有缓存节点所需的全部逻辑。
**下载 ElastiCache Cluster Client**
1. 登录 AWS 管理控制台并打开 ElastiCache 控制台 ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/))。
1. 在 ElastiCache 控制台上，选择 **ElastiCache Cluster Client**，然后选择 **Download（下载）**。
ElastiCache Cluster Client for Java 的源代码可在 [https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java) 获取。此库是以常见的 Spymemcached 客户端为基础。ElastiCache Cluster Client 根据亚马逊软件许可 [https://aws.amazon.com/asl](https://aws.amazon.com/asl) 发布。您可以按照自己的方式自由修改源代码。您甚至可以将代码并入其他开放源 Memcached 库中或者您自己的客户端代码中。
**注意**
如要使用适用于 PHP 的 ElastiCache Cluster Client，您首先需要将其安装在您的 Amazon EC2 实例上。有关更多信息，请参阅 [安装适用于 PHP 的 ElastiCache Cluster Client](Appendix.PHPAutoDiscoverySetup.md)。
对于支持 TLS 的客户端，请下载 PHP 版本 7.4 或更高版本的二进制文件。
若要使用适用于 .NET 的 ElastiCache Cluster Client，您首先需要将其安装在您的 Amazon EC2 实例上。有关更多信息，请参阅 [安装适用于 .NET 的 ElastiCache Cluster Client](Appendix.DotNETAutoDiscoverySetup.md)。
## 修改应用程序编程
修改您的应用程序，以便它可以使用 Auto Discovery。以下部分介绍了如何使用适用于 Java、PHP 和 .NET 的 ElastiCache Cluster Client。
**重要**
指定集群的配置终端节点时，请确保其地址中有 ".cfg"，如此处所示。请勿使用 CNAME 或其中没有 ".cfg" 的终端节点。
```
"mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
```
未明确指定集群的配置终端节点会导致配置到特定节点。
# 使用适用于 Java 的 ElastiCache Cluster Client
下述程序演示了如何使用 ElastiCache Cluster Client 以连接到集群配置端点，并将数据项目添加至缓存中。借助 Auto Discovery，程序可在没有任何进一步干预的情况下连接至集群中的所有节点。
```
package com.amazon.elasticache;
import java.io.IOException;
import java.net.InetSocketAddress;
// Import the &AWS;-provided library with Auto Discovery support
import net.spy.memcached.MemcachedClient;
public class AutoDiscoveryDemo {
public static void main(String[] args) throws IOException {
String configEndpoint = "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
Integer clusterPort = 11211;
MemcachedClient client = new MemcachedClient(
new InetSocketAddress(configEndpoint,
clusterPort));
// The client will connect to the other cache nodes automatically.
// Store a data item for an hour.
// The client will decide which cache host will store this item.
client.set("theKey", 3600, "This is the data value");
}
}
```
# 使用适用于 PHP 的 ElastiCache 群集客户端
以下程序演示了如何使用 ElastiCache 集群客户端连接到集群配置终端节点并将数据项添加到缓存。借助 Auto Discovery，程序将在没有任何进一步干预的情况下连接至集群中的所有节点。
要使用适用于 PHP 的 ElastiCache 集群客户端，您首先需要将其安装在您的 Amazon EC2 实例上。有关更多信息，请参阅 [安装适用于 PHP 的 ElastiCache Cluster Client](Appendix.PHPAutoDiscoverySetup.md)。
```
setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);
$dynamic_client->addServer($server_endpoint, $server_port);
/**
* Store the data for 60 seconds in the cluster.
* The client will decide which cache host will store this item.
*/
$dynamic_client->set('key', 'value', 60);
/**
* Configuring the client with Static client mode disables the usage of Auto Discovery
* and the client operates as it did before the introduction of Auto Discovery.
* The user can then add a list of server endpoints.
*/
$static_client = new Memcached('persistent-id');
$static_client->setOption(Memcached::OPT_CLIENT_MODE, Memcached::STATIC_CLIENT_MODE);
$static_client->addServer($server_endpoint, $server_port);
/**
* Store the data without expiration.
* The client will decide which cache host will store this item.
*/
$static_client->set('key', 'value');
?>
```
有关如何在启用 TLS 的情况下使用 ElastiCache 集群客户端的示例，请参阅在 [PHP 和 Memcached 中使用传输中加密](in-transit-encryption.md#in-transit-encryption-connect-php-mc)。
# 使用适用于 .NET 的 ElastiCache Cluster Client
**注意**
截至 2022 年 5 月，ElastiCache .NET 集群客户端已被弃用。
适用于 ElastiCache 的 .NET 客户端是发布在 [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net) 上的开源客户端。
.NET 应用程序通常会从其配置文件中获取其配置。下面是一个应用程序配置文件示例。
```
```
下述 C\$1 程序演示了如何使用 ElastiCache Cluster Client 以连接到集群配置端点，并将数据项目添加至缓存中。借助 Auto Discovery，程序将在没有任何进一步干预的情况下连接至集群中的所有节点。
```
// *****************
// Sample C# code to show how to integrate with the Amazon ElastiCcache Auto Discovery feature.
using System;
using Amazon.ElastiCacheCluster;
using Enyim.Caching;
using Enyim.Caching.Memcached;
public class DotNetAutoDiscoveryDemo {
public static void Main(String[] args) {
// instantiate a new client.
ElastiCacheClusterConfig config = new ElastiCacheClusterConfig();
MemcachedClient memClient = new MemcachedClient(config);
// Store the data for 3600 seconds (1hour) in the cluster.
// The client will decide which cache host will store this item.
memClient.Store(StoreMode.Set, 3600, "This is the data value.");
} // end Main
} // end class DotNetAutoDiscoverDemo
```
# 手动连接至 Memcached 缓存节点
如果您的客户端程序未使用 Auto Discovery，那么它可以手动连接至每一个 Memcached 缓存节点。这是 Memcached 客户端的默认行为。
您可以从 [AWS管理控制台](https://aws.amazon.com/console/)获取一份缓存节点主机名和端口号列表。您也可以使用带`--show-cache-node-info`参数的AWS CLI`aws elasticache describe-cache-clusters`命令。
**Example**
下方 Java 代码片段显示了如何连接至四节点集群中的所有节点：
```
...
ArrayList cacheNodes = new ArrayList(
Arrays.asList(
"mycachecluster.fnjyzo.0001.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0002.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0003.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0004.use1.cache.amazonaws.com:11211"));
MemcachedClient cache = new MemcachedClient(AddrUtil.getAddresses(cacheNodes));
...
```
**重要**
如果您通过添加或移除节点来纵向扩展或缩减您的集群，那么您将需要更新客户端代码中的节点列表。
# 在 Memcached 客户端库中添加 Auto Discovery
自动发现功能的配置信息以冗方式存储在每个 Memcached 集群节点中。客户端应用程序可以查询任何缓存节点并获取集群中所有节点的配置信息。
应用程序完成此操作采用的方式取决于缓存引擎版本：
+ 如果缓存引擎版本为 **1.4.14 或更高版本**，请使用 `config` 命令。
+ 如果缓存引擎版本 **低于 1.4.14**，请使用 `get AmazonElastiCache:cluster` 命令。
这两个命令得到的输出结果是相同的，并且在下面的 [输出格式](#AutoDiscovery.AddingToYourClientLibrary.OutputFormat) 部分中加以描述。
## 缓存引擎版本 1.4.14 或更高版本
对于缓存引擎版本 1.4.14 或更高版本，请使用 `config` 命令。此命令已由群集客户端添加到 Memcached ASCII 和二进制协议中 ElastiCache，并在 ElastiCache 群集客户端中实现。如果您想将 Auto Discovery 与其他客户端库一同使用，那么将需要对此库进行扩展，以支持 `config` 命令。
**注意**
下面的文档与 ASCII 协议有关；然而，`config` 命令支持 ASCII 和库。如果要使用二进制协议添加自动发现支持，请参阅[ ElastiCache 群集客户端的源代码](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java/tree/master/src/main/java/net/spy/memcached/protocol/binary)。
**语法**
`config [sub-command] [key]`
### 选项
| Name | 说明 | 必填 |
| --- | --- | --- |
| sub-command | 用于与缓存节点互动的子命令。对于 Auto Discovery，这个子命令为 `get`。 | 是 |
| key | 存储集群配置的密钥。对于 Auto Discovery，这个密钥的名称为 `cluster`。 | 是 |
如要获取集群配置信息，请使用下述命令：
```
config get cluster
```
## 缓存引擎版本 1.4.14 或更低版本
如要获取集群配置信息，请使用下述命令：
```
get AmazonElastiCache:cluster
```
**注意**
请勿篡改 “: clusterAmazonElastiCache” 密钥，因为这是集群配置信息所在的地方。如果您确实覆盖了此密钥，则在 ElastiCache 自动正确更新配置信息之前，客户端可能会在短时间内（不超过 15 秒）内被错误配置。
## 输出格式
无论您使用 `config get cluster` 或 `get AmazonElastiCache:cluster`，回复都由两行组成：
+ 配置信息的版本号。每当在集群中添加一个节点或者从集群中移除一个节点时，版本号都会增加一个数。
+ 一份缓存节点列表。列表中的各个节点都由 *用户名\$1IP 地址\$1端口* 组加以表示，并且每个节点都由一个空格加以限定。
回车和换行字符 (CR \$1 LF) 出现在每行末尾处。数据行末尾包含一个换行字符 (LF)，其中添加了 CR \$1 LF。配置版本行以 LF 终止，无需 CR。
包含三个节点的集群的表示方式如下：
```
configversion\n
hostname|ip-address|port hostname|ip-address|port hostname|ip-address|port\n\r\n
```
每个节点都会用 CNAME 和私有 IP 地址显示。CNAME 将会始终加以显示；如果私有 IP 地址不可用，则不会显示；然而，管道字符“`|`”仍会被印出。
**Example**
下面介绍了一个示例，即当您询问配置信息时返回的有效负载：
```
CONFIG cluster 0 136\r\n
12\n
myCluster.pc4ldq.0001.use1.cache.amazonaws.com|10.82.235.120|11211 myCluster.pc4ldq.0002.use1.cache.amazonaws.com|10.80.249.27|11211\n\r\n
END\r\n
```
**注意**
第二行表示迄今为止已修改配置信息 12 次。
在第三行中，节点列表按照主机名的字母顺序进行排序。这种排序可能与您目前在客户端应用程序中采用的顺序不同。
# ElastiCache 具有 auto 发现功能的客户端
集群客户端程序可以自动识别并连接到运行 Memcached 引擎的所有集群节点。
本节讨论安装和配置用于自动发现的 ElastiCache PHP 和.NET 客户端。
**Topics**
+ [安装和编译集群客户端](Appendix.InstallingClients.md)
+ [配置 ElastiCache 客户端](ClientConfig.md)
# 安装和编译集群客户端
本部分介绍如何安装、配置和编译 PHP 以及 .NET Amazon ElastiCache Auto Discovery 集群客户端。
**Topics**
+ [安装适用于 .NET 的 ElastiCache Cluster Client](Appendix.DotNETAutoDiscoverySetup.md)
+ [安装适用于 PHP 的 ElastiCache Cluster Client](Appendix.PHPAutoDiscoverySetup.md)
+ [编译适用于 PHP 的 ElastiCache Cluster Client 的源代码](Appendix.PHPAutoDiscoveryCompile.md)
# 安装适用于 .NET 的 ElastiCache Cluster Client
您可以在 [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net) 上找到开源的 ElastiCache .NET Cluster Client 代码。
本部分说明如何在 Amazon EC2 实例上安装、更新和移除适用于 ElastiCache Cluster Client 的 .NET 组件。有关 Auto Discovery 的更多信息，请参阅 [自动识别集群（Memcached）中的节点](AutoDiscovery.md)。有关使用客户端的 .NET 代码示例，请参阅 [使用适用于 .NET 的 ElastiCache Cluster Client](AutoDiscovery.Using.ModifyApp.DotNET.md)。
**Topics**
+ [安装 .NET](#Appendix.DotNETAutoDiscoverySetup.DotNET)
+ [下载适用于 ElastiCache 的 ElastiCache .NET 集群客户端](#Appendix.DotNETAutoDiscoverySetup.Downloading)
+ [使用 NuGet 安装 AWS 程序集](#Appendix.DotNETAutoDiscoverySetup.Installing)
## 安装 .NET
您必须安装了 .NET 3.5 或更高版本才能使用 AWS .NET SDK for ElastiCache。如果您未安装 .NET 3.5 或更高版本，则可从 [http://www.microsoft.com/net](http://www.microsoft.com/net) 下载并安装最新版本。
## 下载适用于 ElastiCache 的 ElastiCache .NET 集群客户端
**下载 ElastiCache .NET 集群客户端**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台 ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/))。
1. 在导航窗格中，单击 **ElastiCache Cluster Client**。
1. 在 **Download ElastiCache Memcached Cluster Client** 列表中，选择 **.NET**，然后单击 **Download**。
## 使用 NuGet 安装 AWS 程序集
NuGet 是 .NET 平台的包管理系统。NuGet 知道程序集依赖项并自动安装所有必需的文件。NuGet 安装的程序集将与您的解决方案存储在一起，而不是存储在 `Program Files` 这样的中央位置，因此您可安装特定于应用程序的版本，而不会产生兼容性问题。
### 安装 NuGet
NuGet 可从 MSDN 上的安装库进行安装；请参阅 [https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c](https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c)。如果您使用的是 Visual Studio 2010 或更高版本，则将自动安装 NuGet。
您可从 **Solution Explorer (解决方案资源管理器)** 或 **Package Manager Console (包管理器控制台)** 使用 NuGet。
### 从解决方案资源管理器使用 NuGet
**从 Visual Studio 2010 的解决方案资源管理器中使用 NuGet**
1. 从 **Tools (工具)** 菜单中，选择 **Library Package Manager (库包管理器)**。
1. 单击 **Package Manager Console**（软件包管理器控制台）。
**从 Visual Studio 2012 或 Visual Studio 2013 的解决方案资源管理器中使用 NuGet**
1. 从 **Tools (工具)** 菜单中，选择 **NuGet Package Manager (NuGet 包管理器)**。
1. 单击 **Package Manager Console**（软件包管理器控制台）。
从命令行中，您可使用 `Install-Package` 安装程序集，如下所示。
```
Install-Package Amazon.ElastiCacheCluster
```
若要查看可通过 NuGet 提供的每个程序包（例如 AWS 开发工具包和 AWS Extensions 程序集）对应的网页，请参阅 NuGet 网站 ([http://www.nuget.org](http://www.nuget.org))。每个包对应的网页包括一个用于通过控制台安装包的示例命令行和一个列表（其中包含可通过 NuGet 使用的包的早期版本）。
有关 **Package Manager Console (包管理器控制台)** 命令的更多信息，请参阅 [http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29](http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29)。
# 安装适用于 PHP 的 ElastiCache Cluster Client
本部分说明如何在 Amazon EC2 实例上安装、更新和移除适用于 ElastiCache Cluster Client 的 PHP 组件。有关 Auto Discovery 的更多信息，请参阅 [自动识别集群（Memcached）中的节点](AutoDiscovery.md)。有关使用客户端的 PHP 示例代码，请参阅[使用适用于 PHP 的 ElastiCache 群集客户端](AutoDiscovery.Using.ModifyApp.PHP.md)。
**Topics**
+ [下载安装包](Appendix.PHPAutoDiscoverySetup.Downloading.md)
+ [针对已经安装 *php-memcached* 扩展的用户](#Appendix.PHPAutoDiscoverySetup.InstallingExisting)
+ [新用户安装步骤](Appendix.PHPAutoDiscoverySetup.Installing.md)
+ [移除 PHP 集群客户端](Appendix.PHPAutoDiscoverySetup.Removing.md)
# 下载安装包
为了确保适用于 PHP 的 ElastiCache Cluster Client 的版本正确，您需要了解您的 Amazon EC2 实例上安装的是哪一个版本的 PHP。此外，还需要知道您的 Amazon EC2 实例是在 64 位还是 32 位版本的 Linux 上运行的。
**确定安装在 Amazon EC2 实例上的 PHP 版本**
+ 在命令提示符下，运行以下命令：
```
php -v
```
PHP 版本将在输出中显示，如本示例所示：
```
PHP 5.4.10 (cli) (built: Jan 11 2013 14:48:57)
Copyright (c) 1997-2012 The PHP Group
Zend Engine v2.4.0, Copyright (c) 1998-2012 Zend Technologies
```
**注意**
如果您的 PHP 版本与 Memcached 版本不兼容，您会收到与下面类似的错误消息：
```
PHP Warning: PHP Startup: memcached: Unable to initialize module
Module compiled with module API=20100525
PHP compiled with module API=20131226
These options need to match
in Unknown on line 0
```
如果出现这种情况，您需要从源代码编译模块。有关更多信息，请参阅 [编译适用于 PHP 的 ElastiCache Cluster Client 的源代码](Appendix.PHPAutoDiscoveryCompile.md)。
**确定您的 Amazon EC2 AMI 架构（64 位或 32 位）**
1. 登录到 AWS 管理控制台 并打开 Amazon EC2 控制台（[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)）。
1. 在 **Instances（实例）**列表中，单击您的 Amazon EC2 实例。
1. 在 **Description** 选项卡上，查找 **AMI:** 字段。64 位实例应该把 `x86_64` 作为描述的一部分；对于 32 位实例，查找本字段中的 `i386` 或 `i686`。
您现在准备下载 ElastiCache Cluster Client。
**下载适用于 PHP 的 ElastiCache Cluster Client**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台 ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/))。
1. 在 ElastiCache 控制台中，选择 **ElastiCache Cluster Client**。
1. 从 **Download ElastiCache Memcached Cluster Client（下载 ElastiCache Memcached Cluster Client）**列表中，选择与 PHP 版本和 AMI 架构匹配的 ElastiCache Cluster Client，然后选择 **Download（下载）**按钮。
## 针对已经安装 *php-memcached* 扩展的用户
**更新 `php-memcached` 安装**
1. 移除先前安装的适用于 PHP 的 Memcached 扩展，如主题[移除 PHP 集群客户端](Appendix.PHPAutoDiscoverySetup.Removing.md)所述。
1. 如前面的 [新用户安装步骤](Appendix.PHPAutoDiscoverySetup.Installing.md) 中所述，安装新的 ElastiCache `php-memcached` 扩展。
# 新用户安装步骤
**Topics**
+ [为新用户安装 PHP 7.x](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x)
+ [为新用户安装 PHP 5.x](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x)
## 为新用户安装 PHP 7.x
**Topics**
+ [在 Ubuntu Server 14.04 LTS AMI（64 位和 32 位）上安装 PHP 7](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.Ubuntu)
+ [在 Amazon Linux 201609 AMI 上安装 PHP 7](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.AmznLinux)
+ [在 SUSE Linux AMI 上安装 PHP 7](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.SuseLinux)
### 在 Ubuntu Server 14.04 LTS AMI（64 位和 32 位）上安装 PHP 7
1. 从 AMI 启动新实例。
1. 运行以下命令：
```
sudo apt-get update
sudo apt-get install gcc g++
```
1. 安装 PHP 7。
```
sudo yum install php70
```
1. 下载 Amazon ElastiCache Cluster Client。
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. 提取 `latest-64bit`。
```
tar -zxvf latest-64bit
```
1. 在具有 Root 权限的情况下，将提取的工件文件 `amazon-elasticache-cluster-client.so` 复制到 `/usr/lib/php/20151012`。
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib/php/20151012
```
1. 将 `extension=amazon-elasticache-cluster-client.so` 行插入到文件 `/etc/php/7.0/cli/php.ini`。
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php/7.0/cli/php.ini
```
1. 启动或重启 Apache 服务器。
```
sudo /etc/init.d/httpd start
```
### 在 Amazon Linux 201609 AMI 上安装 PHP 7
1. 从 AMI 启动新实例。
1. 运行以下命令：
```
sudo yum install gcc-c++
```
1. 安装 PHP 7。
```
sudo yum install php70
```
1. 下载 Amazon ElastiCache Cluster Client。
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. 提取 `latest-64bit`。
```
tar -zxvf latest-64bit
```
1. 在具有 Root 权限的情况下，将提取的构件文件 `amazon-elasticache-cluster-client.so` 复制到 `/usr/lib64/php/7.0/modules/`。
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php/7.0/modules/
```
1. 创建 `50-memcached.ini` 文件。
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php-7.0.d/50-memcached.ini
```
1. 启动或重启 Apache 服务器。
```
sudo /etc/init.d/httpd start
```
### 在 SUSE Linux AMI 上安装 PHP 7
1. 从 AMI 启动新实例。
1. 运行以下命令：
```
sudo zypper install gcc
```
1. 安装 PHP 7。
```
sudo yum install php70
```
1. 下载 Amazon ElastiCache Cluster Client。
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. 提取 `latest-64bit`。
```
tar -zxvf latest-64bit
```
1. 在具有 Root 权限的情况下，将提取的构件文件 `amazon-elasticache-cluster-client.so` 复制到 `/usr/lib64/php7/extensions/`。
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php7/extensions/
```
1. 将 `extension=amazon-elasticache-cluster-client.so` 行插入到文件 `/etc/php7/cli/php.ini`。
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php7/cli/php.ini
```
1. 启动或重启 Apache 服务器。
```
sudo /etc/init.d/httpd start
```
## 为新用户安装 PHP 5.x
**Topics**
+ [在 Amazon Linux AMI 2014.03（64 位和 32 位）上安装 PHP 5](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.AmznLinux)
+ [在 Red Hat Enterprise Linux 7.0 AMI（64 位和 32 位）上安装 PHP 5](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.RHEL)
+ [在 Ubuntu Server 14.04 LTS AMI（64 位和 32 位）上安装 PHP 5](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Ubuntu)
+ [为 SUSE Linux Enterprise Server 11 AMI（64 位或 32 位）安装 PHP 5](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.SuseLinux)
+ [其他 Linux 分配](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Other)
### 在 Amazon Linux AMI 2014.03（64 位和 32 位）上安装 PHP 5
1. 启动一个 Amazon Linux 实例（64 位或 32 位），然后登录。
1. 安装 PHP 依赖项：
```
sudo yum install gcc-c++ php php-pear
```
1. 下载适用于您的 Amazon EC2 实例和 PHP 版本的正确 `php-memcached` 软件包。有关更多信息，请参阅 [下载安装包](Appendix.PHPAutoDiscoverySetup.Downloading.md)。
1. 安装 `php-memcached`。URI 应为安装包的下载路径：
```
sudo pecl install
```
这是一个关于 PHP 5.4、64 位 Linux 的示例安装命令。在这个示例中，使用实际版本号代替 *X.Y.Z*：
```
sudo pecl install /home/AmazonElastiCacheClusterClient-X.Y.Z-PHP54-64bit.tgz
```
**注意**
请务必使用最新版本的安装工件。
1. 在具有 Root/Sudo 权限的情况下，在 `memcached.ini` 目录中添加一个名为 `/etc/php.d` 的新文件，然后在该文件中插入“extension=amazon-elasticache-cluster-client.so”：
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. 启动或重启 Apache 服务器。
```
sudo /etc/init.d/httpd start
```
### 在 Red Hat Enterprise Linux 7.0 AMI（64 位和 32 位）上安装 PHP 5
1. 启动一个 Red Hat Enterprise Linux 实例（64 位或 32 位），然后登录。
1. 安装 PHP 依赖项：
```
sudo yum install gcc-c++ php php-pear
```
1. 下载适用于您的 Amazon EC2 实例和 PHP 版本的正确 `php-memcached` 软件包。有关更多信息，请参阅 [下载安装包](Appendix.PHPAutoDiscoverySetup.Downloading.md)。
1. 安装 `php-memcached`。URI 应为安装包的下载路径：
```
sudo pecl install
```
1. 在具有 Root/Sudo 权限的情况下，在 `memcached.ini` 目录中添加一个名为 `/etc/php.d` 的新文件，然后在该文件中插入 `extension=amazon-elasticache-cluster-client.so`。
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. 启动或重启 Apache 服务器。
```
sudo /etc/init.d/httpd start
```
### 在 Ubuntu Server 14.04 LTS AMI（64 位和 32 位）上安装 PHP 5
1. 启动一个 Ubuntu Linux 实例（64 位或 32 位），然后登录。
1. 安装 PHP 依赖项：
```
sudo apt-get update
sudo apt-get install gcc g++ php5 php-pear
```
1. 下载适用于您的 Amazon EC2 实例和 PHP 版本的正确 `php-memcached` 软件包。有关更多信息，请参阅 [下载安装包](Appendix.PHPAutoDiscoverySetup.Downloading.md)。
1. 安装 `php-memcached`。URI 应为安装包的下载路径。
```
sudo pecl install
```
**注意**
此安装步骤将构建工件 `amazon-elasticache-cluster-client.so` 安装到 `/usr/lib/php5/20121212*` 目录中。请核对构建工件的绝对路径，因为您在下一个步骤中需要使用此路径。
如果上一个命令不起作用，则需要从下载的 `amazon-elasticache-cluster-client.so` 文件中手动提取 PHP 客户端工件 `*.tgz`，将它复制到 `/usr/lib/php5/20121212*` 目录。
```
tar -xvf
cp amazon-elasticache-cluster-client.so /usr/lib/php5/20121212/
```
1. 在具有 Root/Sudo 权限的情况下，在 `memcached.ini` 目录中添加一个名为 `/etc/php5/cli/conf.d` 的新文件，然后在该文件中插入“extension=”。
```
echo "extension=" | sudo tee --append /etc/php5/cli/conf.d/memcached.ini
```
1. 启动或重启 Apache 服务器。
```
sudo /etc/init.d/httpd start
```
### 为 SUSE Linux Enterprise Server 11 AMI（64 位或 32 位）安装 PHP 5
1. 启动一个 SUSE Linux 实例（64 位或 32 位），然后登录。
1. 安装 PHP 依赖项：
```
sudo zypper install gcc php53-devel
```
1. 下载适用于您的 Amazon EC2 实例和 PHP 版本的正确 `php-memcached` 软件包。有关更多信息，请参阅 [下载安装包](Appendix.PHPAutoDiscoverySetup.Downloading.md)。
1. 安装 `php-memcached`。URI 应为安装包的下载路径。
```
sudo pecl install
```
1. 在具有 Root/Sudo 权限的情况下，在 `memcached.ini` 目录中添加一个名为 `/etc/php5/conf.d` 的新文件，然后在该文件中插入 **extension=`amazon-elasticache-cluster-client.so`**。
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php5/conf.d/memcached.ini
```
1. 启动或重启 Apache 服务器。
```
sudo /etc/init.d/httpd start
```
**注意**
如果步骤 5 不适用于任何以前的平台，请验证 `amazon-elasticache-cluster-client.so` 的安装路径。另外，在扩展中指定二进制文件的完整路径。此外，请确认所用的 PHP 是受支持的版本。我们支持版本 5.3 到 5.5。
### 其他 Linux 分配
在某些系统（特别是 CentOS7 和 Red Hat Enterprise Linux (RHEL) 7.1）上，`libsasl2.so.3` 已替代 `libsasl2.so.2`。在这些系统上，当您加载 ElastiCache 集群客户端时，它会尝试查找和加载 `libsasl2.so.2`，但此尝试将失败。要解决此问题，请创建一个指向 `libsasl2.so.3` 的符号链接，以便在客户端尝试加载 libsasl2.so.2 时将重定向到 `libsasl2.so.3`。以下代码将创建此符号链接。
```
cd /usr/lib64
sudo ln libsasl2.so.3 libsasl2.so.2
```
# 移除 PHP 集群客户端
**Topics**
+ [移除早期版本的 PHP 7](#Appendix.PHPAutoDiscoverySetup.Removing.PHP7x)
+ [移除早期版本的 PHP 5](#Appendix.PHPAutoDiscoverySetup.Removing.PHP5x)
## 移除早期版本的 PHP 7
**移除早期版本的 PHP 7**
1. 依照前述安装说明，从相应的 PHP 库目录中删除 `amazon-elasticache-cluster-client.so` 文件。请参阅[针对已经安装 *php-memcached* 扩展的用户](Appendix.PHPAutoDiscoverySetup.md#Appendix.PHPAutoDiscoverySetup.InstallingExisting)处关于您的安装的部分。
1. 从 `extension=amazon-elasticache-cluster-client.so` 文件中移除 `php.ini` 行。
1. 启动或重启 Apache 服务器。
```
sudo /etc/init.d/httpd start
```
## 移除早期版本的 PHP 5
**移除早期版本的 PHP 5**
1. 移除 `php-memcached` 扩展：
```
sudo pecl uninstall __uri/AmazonElastiCacheClusterClient
```
1. 依照前述安装步骤，移除添加在相应目录中的 `memcached.ini` 文件。
# 编译适用于 PHP 的 ElastiCache Cluster Client 的源代码
本部分介绍如何获取和编译适用于 PHP 的 ElastiCache Cluster Client 的源代码。
有两个需要从 GitHub 提取并编译的数据包：[aws-elasticache-cluster-client-libmemcached](https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached) 和 [aws-elasticache-cluster-client-memcached-for-php](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php)。
**Topics**
+ [编译 libmemcached 库](#Appendix.PHPAutoDiscoveryCompile.Libmemcached)
+ [编译适用于 PHP 的 ElastiCache Memcached Auto Discovery 客户端](#Appendix.PHPAutoDiscoveryCompile.Client)
## 编译 libmemcached 库
**编译 aws-elasticache-cluster-client-libmemcached 库**
1. 启动 Amazon EC2 实例。
1. 安装库依赖项。
+ 在 Amazon Linux 201509 AMI 上
```
sudo yum install gcc gcc-c++ autoconf libevent-devel
```
+ 在 Ubuntu 14.04 AMI 上
```
sudo apt-get update
sudo apt-get install libevent-dev gcc g++ make autoconf libsasl2-dev
```
1. 拉取存储库并编译代码。
```
Download and install [ https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz]( https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz)
```
## 编译适用于 PHP 的 ElastiCache Memcached Auto Discovery 客户端
以下部分介绍如何编译 ElastiCache Memcached Auto Discovery 客户端
**Topics**
+ [编译适用于 PHP 7 的 ElastiCache Memcached 客户端](#Appendix.PHPAudiscoveryCompile.Client.PHP7)
+ [编译适用于 PHP 5 的 ElastiCache Memcached 客户端](#Appendix.PHPAudiscoveryCompile.PHP5)
### 编译适用于 PHP 7 的 ElastiCache Memcached 客户端
在代码目录下运行下面一组命令。
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
git checkout php7
sudo yum install php70-devel
phpize
./configure --with-libmemcached-dir= --disable-memcached-sasl
make
make install
```
**注意**
您可以将 libmemcached 库静态链接到 PHP 二进制文件，以使其可以跨各种 Linux 平台传输。为此，请在 `make` 之前运行以下命令：
```
sed -i "s#-lmemcached#/lib/libmemcached.a -lcrypt -lpthread -lm -lstdc++ -lsasl2#" Makefile
```
### 编译适用于 PHP 5 的 ElastiCache Memcached 客户端
通过在 `aws-elasticache-cluster-client-memcached-for-php` 文件夹下运行以下命令，编译 `aws-elasticache-cluster-client-memcached-for-php/`。
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
sudo yum install zlib-devel
phpize
./configure --with-libmemcached-dir=
make
make install
```
# 配置 ElastiCache 客户端
ElastiCache 集群兼容 Valkey、Memcached 和 Redis OSS 协议。您目前在现有环境中使用的代码、应用程序和最常用的工具都能与该服务无缝兼容。
本部分讨论有关在 ElastiCache 中连接到缓存节点的特定注意事项。
**Topics**
+ [受限命令](ClientConfig.RestrictedCommands.md)
+ [查找节点端点和端口号](ClientConfig.FindingEndpointsAndPorts.md)
+ [连接以使用 Auto Discovery](ClientConfig.AutoDiscovery.md)
+ [连接到 Valkey 或 Redis OSS 集群中的节点](ClientConfig.ReplicationGroup.md)
+ [DNS 名称和底层 IP](ClientConfig.DNS.md)
# 受限命令
为了提供托管服务体验， ElastiCache 限制对某些需要高级权限的缓存引擎特定命令的访问权限。对于运行 Redis OSS 的集群，以下命令不可用：
+ `bgrewriteaof`
+ `bgsave`
+ `config`
+ `debug`
+ `migrate`
+ `replicaof`
+ `save`
+ `slaveof`
+ `shutdown`
+ `sync`
# 查找节点端点和端口号
要连接到某个缓存节点，您的应用程序需要知道该节点的终端节点和端口号。
## 查找节点端点和端口号（控制台）
**确定节点终端节点和端口号**
1. 登录 [Amazon ElastiCache 管理控制台](https://aws.amazon.com/elasticache)，然后选择在集群上运行的引擎。
此时会显示运行所选引擎的所有集群的列表。
1. 对您运行的引擎和配置继续下面的操作。
1. 选择所需集群的名称。
1. 找到所需节点的 **Port** 和 **Endpoint** 列。
## 查找缓存节点端点和端口号 (AWS CLI)
要确定缓存节点终端节点和端口号，请使用带 `describe-cache-clusters` 参数的命令 `--show-cache-node-info`。
```
aws elasticache describe-cache-clusters --show-cache-node-info
```
完全限定的 DNS 名称和端口号处于输出的终端节点部分。
## 查找缓存节点端点和端口号 (ElastiCache API)
要确定缓存节点终端节点和端口号，请使用带 `DescribeCacheClusters` 参数的操作 `ShowCacheNodeInfo=true`。
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ShowCacheNodeInfo=true
4. &SignatureVersion=4
5. &SignatureMethod=HmacSHA256
6. &Timestamp=20140421T220302Z
7. &Version=2014-09-30
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Credential=
10. &X-Amz-Date=20140421T220302Z
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Signature=
13. &X-Amz-SignedHeaders=Host
```
# 连接以使用 Auto Discovery
如果您的应用程序使用 Auto Discovery，则您只需知道集群的配置终端节点，而不是每个缓存节点的各个终端节点。有关更多信息，请参阅 [自动识别集群（Memcached）中的节点](AutoDiscovery.md)。
**注意**
此时，自动发现功能只能用于运行 Memcached 的集群。
# 连接到 Valkey 或 Redis OSS 集群中的节点
**注意**
目前，对于支持复制和只读副本的集群（API/CLI：复制组），只有运行 Valkey 或 Redis OSS 的集群才能够提供支持。
对于集群，ElastiCache 提供控制台、CLI 和 API 接口来获取各个节点的连接信息。
对于只读活动，应用程序可以连接到集群的任何节点。不过，对于写入活动，我们建议您的应用程序连接到集群的主端点 [Valkey 或 Redis OSS（已禁用集群模式）]或配置端点 [Valkey 或 Redis OSS（已启用集群模式）]，而不是直接连接到某个节点。这样可确保您的应用程序始终可以找到正确的节点，即使您决定通过将只读副本提升为主角色来重新配置集群。
## 连接到复制组（控制台）中的集群
**确定终端节点和端口号**
+ 请参阅主题，[查找 Valkey 或 Redis OSS（已禁用集群模式）集群端点（控制台）](Endpoints.md#Endpoints.Find.Redis)。
## 连接到复制组 (AWS CLI) 中的集群
**确定缓存节点终端节点和端口号**
使用带有复制组名称的命令 `describe-replication-groups`：
```
aws elasticache describe-replication-groups redis2x2
```
该命令应该生成类似于下述信息的输出：
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "redis2x2.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "redis2x2",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"redis2x2-0001-001",
"redis2x2-0001-002",
"redis2x2-0002-001",
"redis2x2-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"PendingModifiedValues": {}
}
]
}
```
## 连接到复制组 (ElastiCache API) 中的集群
**确定缓存节点终端节点和端口号**
按照以下参数请求 `DescribeReplicationGroups`：
`ReplicationGroupId` = 复制组的名称。
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ReplicationGroupId=repgroup01
4. &Version=2014-09-30
5. &SignatureVersion=4
6. &SignatureMethod=HmacSHA256
7. &Timestamp=20140421T220302Z
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Date=20140421T220302Z
10. &X-Amz-SignedHeaders=Host
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Credential=
13. &X-Amz-Signature=
```
# DNS 名称和底层 IP
客户端维护一份服务器列表，其中包含保存缓存数据的服务器的地址和端口。在使用 ElastiCache 时，DescribeCacheClusters API（或 describe-cache-clusters 命令行实用工具）会返回可用于服务器列表的完全限定 DNS 条目和端口号。
**重要**
重要的是配置客户端应用程序，以便在它们尝试连接到缓存节点终端节点时频繁地解析缓存节点的 DNS 名称。
当缓存节点发生故障恢复时，ElastiCache 可确保缓存节点的 DNS 名称保持不变。
大多数客户端库默认支持持久性缓存节点连接。我们建议您在使用 ElastiCache 时采用持久性缓存节点连接。客户端 DNS 缓存可以出现在多个位置，包括客户端库、语言运行时或客户端操作系统。您应该检查每一层的应用程序配置，以确保您可以频繁地解析您的缓存节点 IP 地址。
# ElastiCache 中的数据分层
包含复制组且使用 r6gd 系列节点类型的 ElastiCache for Valkey 或 ElastiCache for Redis OSS 集群将在内存和本地 SSD（固态硬盘）存储之间进行数据分层。借助数据分层功能，除可在内存中存储数据外，还可以在每个集群节点中使用成本更低的固态硬盘（SSD），从而为 Valkey 或 Redis OSS 工作负载提供新的高性价比选择。它非常适合经常访问的数据不超过总体数据集的 20% 的工作负载，以及能够容忍访问 SSD 中数据时所出现的额外延迟的应用程序。
对于启用了数据分层功能的 ElastiCache 集群，ElastiCache 会监控集群所存储每个项目的最近访问时间。当可用内存 (DRAM) 耗尽时，ElastiCache 将使用最近最少使用 (LRU) 算法，自动将不频繁访问的项目从内存移动到 SSD 中。随后访问 SSD 上的数据时，ElastiCache 会在处理请求之前自动异步将其移回内存中。如果您的工作负载只会经常访问部分数据，则数据分层将是经济高效地扩缩容量的极佳方法。
请注意，使用数据分层时，键本身始终保留在内存中，而 LRU 将控制值在内存和磁盘上的位置。通常，在使用数据分层时，我们建议您的键大小小于值。
数据分层旨在将对应用程序工作负载的性能影响降至最低。例如，假设 500 字节的字符串值，与请求存储在内存中的数据相比，请求存储在 SSD 上的数据预计平均会增加 300 微秒的延迟。
如果使用最大型号的数据分层节点 (cache.r6gd.16xlarge)，您可以在单个 500 节点集群中存储最高 1PB 的数据（使用 1 个只读副本时 500TB）。数据分层功能兼容 ElastiCache 中支持的所有 Valkey 或 Redis OSS 命令和数据结构。使用此功能无需任何客户端更改。
**Topics**
+ [最佳实践](#data-tiering-best-practices)
+ [限制](#data-tiering-prerequisites)
+ [定价](#data-tiering-pricing)
+ [监控](#data-tiering-monitoring)
+ [数据分层功能的使用](#data-tiering-enabling)
+ [将数据从备份还原到启用数据分层的集群](#data-tiering-enabling-snapshots)
## 最佳实践
我们建议您遵循以下最佳实践：
+ 数据分层非常适合经常访问的数据不超过总体数据集的 20% 的工作负载，以及能够容忍访问 SSD 中数据时所出现的额外延迟的应用程序。
+ 在数据分层节点上使用可用的 SSD 容量时，我们建议值大小大于键。在 DRAM 和 SSD 之间移动项目时，键将始终保留在内存中，并且只有值会移动到 SSD 层。
## 限制
数据分层功能存在以下限制：
+ 您只能在复制组中的集群上使用数据分层。
+ 您使用的节点类型必须属于 r6gd 系列，目前可在以下区域使用：`us-east-2`、`us-east-1`、`us-west-2`、`us-west-1`、`eu-west-1`、`eu-central-1`、`eu-north-1`、`eu-west-3`、`ap-northeast-1`、`ap-southeast-1`、`ap-southeast-2`、`ap-south-1`、`ca-central-1` 和 `sa-east-1`。
+ 您必须使用 Valkey 7.2 或更高版本的引擎，或者使用 Redis OSS 6.2 或更高版本的引擎。
+ 除非两个集群都为 r6gd 集群，否则不能将 r6gd 集群的备份还原到其他集群。
+ 不能将使用数据分层功能的集群备份导出到 Amazon S3。
+ 在 r6gd 节点类型上运行的集群不支持在线迁移。
+ 不支持将使用数据分层功能的集群（例如，使用 r6gd 节点类型的集群）扩缩至不使用数据分层功能的集群（例如，使用 r6g 节点类型的集群）。有关更多信息，请参阅 [缩放 ElastiCache](Scaling.md)。
+ 对于 Valkey 7.2 及更高版本和 Redis OSS 7.0.7 及更高版本，使用数据分层的集群支持自动扩缩。有关更多信息，请参阅 [自动扩缩 Valkey 和 Redis OSS 集群](AutoScaling.md)。
+ 数据分层仅支持 `volatile-lru`、`allkeys-lru`、`volatile-lfu`、`allkeys-lfu` 和 `noeviction` maxmemory 策略。
+ Valkey 7.2 及更高版本和 Redis OSS 7.0.7 及更高版本支持无分支保存。有关更多信息，请参阅 [如何实施同步和备份](Replication.Redis.Versions.md)。
+ 大于 128MiB 的项目不会移动到 SSD。
+ 从 Valley 8.1 及更高版本开始，键 \$1 值大小小于 40 字节的项目将不会移至 SSD。
## 定价
与 R6g 节点（仅内存）相比，R6gd 节点的总存储容量（内存 \$1 SSD）提高了 4.8 倍，以最大利用率运行时可帮助实现超过 60% 的节省。有关更多信息，请参阅 [ElastiCache 定价](https://aws.amazon.com/elasticache/pricing/)。
## 监控
ElastiCache 提供了若干专用于监控使用数据分层功能的高性能集群的指标。要监控 DRAM 中的项目与 SSD 的比例，可以使用 [Valkey 和 Redis OSS 的指标](CacheMetrics.Redis.md)中的 `CurrItems` 指标。您可以按以下方式计算百分比：*（带维度的 CurrItems：分层 = 内存 \$1 100）/（不带维度筛选器的 CurrItems）*。
如果配置的 eviction 策略允许，那么当内存中的项目百分比降至 5% 以下时，ElastiCache 将开始移出项目。在配置了 noeviction 策略的节点上，写入操作将收到内存不足错误。
当内存中的项目百分比降至 5% 以下时，我们建议您考虑横向扩展已启用集群模式的集群的规模，或纵向扩展已禁用集群模式的集群的规模。有关扩展的更多信息，请参阅[扩缩 Valkey 或 Redis OSS（已启用集群模式）集群](scaling-redis-cluster-mode-enabled.md)。有关使用数据分层的 Valkey 或 Redis OSS 集群指标的更多信息，请参阅 [Valkey 和 Redis OSS 的指标](CacheMetrics.Redis.md)。
## 数据分层功能的使用
### 通过 AWS 管理控制台使用数据分层功能
您可在创建复制组中的集群时选择 r6gd 系列的节点类型（例如 *cache.r6gd.xlarge*），从而使用数据分层功能。选择该节点类型将会自动启用数据分层功能。
有关创建集群的更多信息，请参阅[创建 Valkey 或 Redis OSS 集群](Clusters.Create.md)。
### 通过 AWS CLI 启用数据分层
您可在使用 AWS CLI 创建复制组时选择 r6gd 系列的节点类型（例如 *cache.r6gd.xlarge*）并设置 `--data-tiering-enabled` 参数，从而使用数据分层功能。
选择 r6gd 系列的节点类型时，您将不能选择停止使用数据分层功能。如果您设置 `--no-data-tiering-enabled` 参数，操作将会失败。
对于 Linux、macOS 或 Unix：
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled
```
对于 Windows：
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled
```
运行此操作后，您将会看到一条与以下类似的响应：
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
## 将数据从备份还原到启用数据分层的集群
您可以通过（控制台）、(AWS CLI) 或 (ElastiCache API) 将数据从备份还原到启用数据分层的新集群。当您使用 r6gd 系列的节点类型创建集群时，系统会启用数据分层。
### 将数据从备份还原到启用数据分层的集群（控制台）
**从备份还原到启用数据分层的集群（控制台）**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 从导航窗格中，选择 **Backups**（备份）。
1. 在备份列表中，选择您要从中进行还原的备份名称左侧的复选框。
1. 选择 **Restore**（还原）。
1. 完成 **Restore Cluster**（还原集群）对话框。务必要填写所有 **Required**（必填）字段以及您希望更改原定设置的任何其他字段。
1. **Cluster ID**（集群 ID）– 必填。新集群的名称。
1. **已启用集群模式（横向扩展）**– 对 Valkey 或 Redis OSS（已启用集群模式）集群选择此项。
1. **Node Type**（节点类型）– 选择 **cache.r6gd.xlarge** 或 r6gd 系列中的任何其他节点类型。
1. **Number of Shards**（分片数量）– 选择您希望新集群拥有的分片（API/CLI：节点组）数量。
1. **Replicas per Shard（每个分区的副本数）**– 选择您希望各分区拥有的只读副本节点数量。
1. **Slots and keyspaces（槽和键空间）** – 选择您希望如何在分区之间分布键。如果您选择指定键分配，请完成为各分片指定键范围的表。
1. **Availability zone(s)（可用区）**– 指定您希望如何选择集群的可用区。
1. **Port（端口）**– 仅当您希望新集群使用不同端口时才更改此项。
1. **Choose a VPC（选择 VPC）**– 选择要在其中创建此集群的 VPC。
1. **参数组** – 选择为所选节点类型预留了足够 Valkey 或 Redis OSS 内存开销的参数组。
1. 根据需要进行设置后，选择**创建**。
有关创建集群的更多信息，请参阅[创建 Valkey 或 Redis OSS 集群](Clusters.Create.md)。
### 将数据从备份还原到启用数据分层的集群 (AWS CLI)
使用 AWS CLI 创建复制组时，选择 r6gd 系列的节点类型（例如 *cache.r6gd.xlarge*）并设置 `--data-tiering-enabled` 参数后，系统会默认启用数据分层。
选择 r6gd 系列的节点类型时，您将不能选择停止使用数据分层功能。如果您设置 `--no-data-tiering-enabled` 参数，操作将会失败。
对于 Linux、macOS 或 Unix：
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled \
--snapshot-name my-snapshot
```
对于 Linux、macOS 或 Unix：
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled ^
--snapshot-name my-snapshot
```
运行此操作后，您将会看到一条与以下类似的响应：
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
# 准备在 ElastiCache 中创建集群
接下来，可找到有关使用 ElastiCache 控制台、AWS CLI 或 ElastiCache API 创建集群的说明。
您还可以使用 [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) 创建 ElastiCache 集群。有关更多信息，请参阅《AWS Cloud Formation 用户指南》中的 [AWS::ElastiCache::CacheCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html)，其中包括关于如何实施这一方法的指导意见。
每当创建集群或复制组时，最好做一些准备工作，这样就无需立即升级或进行更改。
**Topics**
+ [确定您的 ElastiCache 集群需求](cluster-create-determine-requirements.md)
+ [选择节点大小](CacheNodes.SelectSize.md)
# 确定您的 ElastiCache 集群需求
**准备**
了解以下问题的答案有助于更顺利地创建 ElastiCache 集群：
+ 您需要哪种节点实例类型？
有关选择实例节点类型的指导信息，请参阅[选择节点大小](CacheNodes.SelectSize.md)。
+ 您是否会在基于 Amazon VPC 的 Virtual Private Cloud (VPC) 中启动集群？
**重要**
如果您打算在 VPC 中启动集群，则需要先在相同 VPC 中创建子网组，然后再开始创建集群。有关更多信息，请参阅 [子网和子网组](SubnetGroups.md)。
ElastiCache 旨在使用 Amazon EC2 从 AWS 内部进行访问。但是，如果根据 Amazon VPC 在 VPC 中启动且集群位于 VPC 中，则可以提供从 AWS 外部进行访问的权限。有关更多信息，请参阅 [从外部访问 ElastiCache 资源AWS](accessing-elasticache.md#access-from-outside-aws)。
+ 您是否需要自定义任何参数值？
如果这样做，请创建自定义参数组。有关更多信息，请参阅 [创建 ElastiCache 参数组](ParameterGroups.Creating.md)。
如果您正在运行 Valkey 或 Redis OSS，请考虑设置 `reserved-memory` 或 `reserved-memory-percent`。有关更多信息，请参阅 [管理 Valkey 和 Redis OSS 的预留内存](redis-memory-management.md)。
+ 您是否需要创建自己的 *VPC 安全组*？
有关更多信息，请参阅[您的 VPC 的安全性](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Security.html)。
+ 您想如何实现容错？
有关更多信息，请参阅 [缓解故障](disaster-recovery-resiliency.md#FaultTolerance)。
**Topics**
+ [ElastiCache 内存和处理器要求](#cluster-create-determine-requirements-memory)
+ [Memcached 集群配置](#memcached-cluster-configuration)
+ [Valkey 和 Redis OSS 集群配置](#redis-cluster-configuration)
+ [ElastiCache 扩展要求](#cluster-create-determine-requirements-scaling)
+ [ElastiCache 访问要求](#cluster-create-determine-requirements-access)
+ [ElastiCache 的区域、可用区和 Local Zones 要求](#cluster-create-determine-requirements-region)
## ElastiCache 内存和处理器要求
Amazon ElastiCache 的基本构建数据块是节点。配置单个节点，或成组配置节点以形成集群。在确定用于集群的节点类型时，请考虑集群的节点配置以及必须存储的数据量。
Memcached 引擎是多线程的，因此节点的内核数会影响可供集群使用的计算能力。
## Memcached 集群配置
ElastiCache for Memcached 集群由 1 到 60 个节点组成。Memcached 集群中的数据在集群中的节点间分区。您的应用程序使用称为终端节点的网络地址与 Memcached 集群连接。Memcached 集群中的每个节点都具有自己的终端节点，应用程序可以使用它来对特定节点进行读取或写入。除了节点终端节点外，Memcached 集群本身还具有一个称为*配置终端节点*的终端节点。您的应用程序可以使用此端点来读取或写入集群，从而由自动发现决定要读取或写入的节点。
![\[图片：显示 Memcached 集群在集群各节点之间如何分区。\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
有关更多信息，请参阅 [在 ElastiCache 中管理集群](Clusters.md)。
## Valkey 和 Redis OSS 集群配置
ElastiCache for Valkey and Redis OSS 集群由 0 到 500 个分片（也称为节点组）组成。Valkey 或 Redis OSS 集群中的数据在集群的分片间分区。您的应用程序使用称为端点的网络地址与 Valkey 或 Redis OSS 集群连接。Valkey 或 Redis OSS 分片中的节点执行以下两个角色之一：一个读取/写入主节点以及所有其他辅助只读节点（也称为只读副本）。除了节点端点外，Valkey 或 Redis OSS 集群本身还具有一个称为*配置端点*的端点。您的应用程序可以使用此端点来读取或写入集群，从而由 ElastiCache for Redis OSS 决定要读取或写入的节点。
![\[图片：比较禁用集群模式与启用集群模式下的 Valkey 或 Redis OSS 集群。\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-Redis-ClustersRGs.png)
有关更多信息，请参阅 [在 ElastiCache 中管理集群](Clusters.md)。
## ElastiCache 扩展要求
通过创建具有更大的新节点类型的新集群，可以对所有集群进行扩展。在纵向扩展 Memcached 集群时，新集群最初为空。纵向扩展 Redis 集群时，您可以从备份中为集群制作种子，避免新集群启动时为空。
Amazon ElastiCache for Memcached 集群可以横向扩展或收缩。要扩展或收缩 Memcached 集群，您只需在集群中添加或删除节点即可。如果已启用 Automatic Discovery 并且您的应用程序已连接到集群的配置终端节点，则在添加或删除节点时不需要在应用程序中进行任何更改。
有关更多信息，请参阅本指南中的[缩放 ElastiCache](Scaling.md)。
## ElastiCache 访问要求
根据设计，Amazon ElastiCache 集群可通过 Amazon EC2 实例进行访问。对 ElastiCache 集群的网络访问限制为创建该集群的账户。因此，必须先授权 Amazon EC2 实例访问集群，然后您才能从 Amazon EC2 实例访问集群。执行此操作的步骤会有所变化，具体取决于启动到 EC2-VPC 还是 EC2-Classic。
如果您已将集群启动到 EC2-VPC，则需向集群授予网络入口。如果将集群启动到 EC2-Classic 中，则需将与实例访问关联的 Amazon Elastic Compute Cloud 安全组授予 ElastiCache 安全组。有关详细说明，请参阅本指南中的 [步骤 3：授予对集群的访问权限](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey)。
## ElastiCache 的区域、可用区和 Local Zones 要求
Amazon ElastiCache 支持所有 AWS 区域。通过将 ElastiCache 集群放置在接近应用程序的 AWS 区域可以降低延迟。如果集群有多个节点，将节点放置在不同的可用区或 Local Zones 可减少故障对集群的影响。
有关更多信息，请参阅下列内容：
+ [为 ElastiCache 选择区域和可用区](RegionsAndAZs.md)
+ [将 Local Zones 与 ElastiCache 结合使用](Local_zones.md)
+ [缓解故障](disaster-recovery-resiliency.md#FaultTolerance)
# 选择节点大小
为 ElastiCache 集群选择的节点大小会影响成本、性能和容错能力。
## 节点大小（Valkey 和 Redis OSS）
有关 Graviton 处理器的优势的信息，请参阅 [AWS Graviton 处理器](https://aws.amazon.com/pm/ec2-graviton/)。
回答以下问题可帮助您决定实施 Valkey 或 Redis OSS 所需的最小节点类型：
+ 是否预期会出现采用多个客户端连接但吞吐量受限的工作负载？
如果是这种情况，并且您运行的是 Redis OSS 版本 5.0.6 或更高版本，则可以为 Redis OSS 引擎使用增强型 I/O 功能来获得更好的吞吐量和延迟，此时可用的 CPU 用于分载客户端连接。如果您运行的是 Redis OSS 版本 7.0.4 或更高版本，则除了增强型 I/O 之外，您还将通过增强型 I/O 多路复用来获得额外的加速，此时，每个专用网络 IO 线程利用 Redis OSS 高效地批量处理命令的能力，将来自多个客户端的命令通过管道传送到 Redis OSS 引擎。在 ElastiCache for Redis OSS 7.1 及更高版本中，我们扩展了增强型 I/O 线程功能，使其还可以处理表示层逻辑。对于表示层，这是指增强型 I/O 线程现在不仅可以读取客户端输入，还可以将输入解析为 Redis OSS 二进制命令格式，然后将其转发到主线程以便执行，从而提高性能。有关更多详细信息，请参阅[博客文章](https://aws.amazon.com/blogs/database/achieve-over-500-million-requests-per-second-per-cluster-with-amazon-elasticache-for-redis-7-1/)和[支持的版本](VersionManagement.md#supported-engine-versions)页面。
+ 您是否有仅会经常访问少部分数据的工作负载？
如果是这种情况，并且您运行的是 Redis OSS 6.2 版或更高版本的引擎，您可以通过选择 r6gd 节点类型来使用数据分层功能。使用数据分层功能时，最近极少使用的数据将存储到 SSD 中。在检索这些数据时，虽然延迟会轻微增加，但是可以节省成本。有关更多信息，请参阅 [ElastiCache 中的数据分层](data-tiering.md)。
有关更多信息，请参阅 [受支持的节点类型](CacheNodes.SupportedTypes.md)。
+ 您的数据共需要多少内存量？
要获得一般估计值，请取要缓存的项目的大小。将此大小乘以同时要保留在缓存中的项目数。要获得项目大小的合理估计值，请先序列化您的缓存项目，再计算字符数。然后将该值除以集群中的分区数。
有关更多信息，请参阅 [受支持的节点类型](CacheNodes.SupportedTypes.md)。
+ 您运行 Redis OSS 的哪个版本？
对于 2.8.22 版之前的 Redis，您需要预留更多内存以用于失效转移、快照、同步和将副本提升为主节点的操作。之所以有此要求，是因为您必须具有足够的内存来执行过程中的所有写入。
Redis OSS 2.8.22 和更高版本使用无分支保存过程，相比之前的过程，所需可用内存更少。
有关更多信息，请参阅下列内容：
+ [如何实施同步和备份](Replication.Redis.Versions.md)
+ [确保具有用于创建 Valkey 或 Redis OSS 快照的足够内存](BestPractices.BGSAVE.md)
+ 您的应用程序的写操作有多密集？
在拍摄快照或进行故障转移时，写操作密集的应用程序需要多得多的可用内存（ 数据未使用的内存）。无论何时执行 `BGSAVE` 进程，必须有足够的、数据未使用的内存，以容纳在 `BGSAVE` 过程中执行的所有写入。例如，拍摄快照时、将主集群与集群中的副本同步时以及启用仅附加文件 (AOF) 功能时。另一个示例是将副本提升为主节点时（如果您启用了多可用区）。最糟糕的情况是在此过程中重写所有数据。在这种情况下，您需要的节点实例大小是数据所需的内存量的两倍。
有关更多详细信息，请参阅 [确保具有用于创建 Valkey 或 Redis OSS 快照的足够内存](BestPractices.BGSAVE.md)。
+ 您的实施是一个独立的 Valkey 或 Redis OSS（已禁用集群模式）集群，还是具有多个分片的 Valkey 或 Redis OSS（已启用集群模式）集群？
**Valkey 或 Redis OSS（已禁用集群模式）集群**
如果您实施的是 Valkey 或 Redis OSS（已禁用集群模式）集群，则节点类型必须能够容纳所有数据及必要的开销，如上一要点中所述。
例如，假设您估计所有项目的总大小为 12GB。在此情况下，您可以使用具有 13.3GB 内存的 `cache.m3.xlarge` 节点 或具有 13.5GB 内存的 `cache.r3.large` 节点。但是，您可能需要更多内存才能执行 `BGSAVE` 操作。如果您的应用程序写入操作繁重，请将内存要求翻倍至至少 24GB。因此，使用具有 27.9GB 内存的 `cache.m3.2xlarge` 或具有 30.5GB 内存的 `cache.r3.xlarge`。
**具有多个分片的 Valkey 或 Redis OSS 集群（已启用集群模式）**
如果您实施的是具有多个分片的 Valkey 或 Redis OSS（已启用集群模式）集群，则节点类型必须能够容纳 `bytes-for-data-and-overhead / number-of-shards` 字节的数据。
例如，假设您估计所有项目的总大小为 12GB 且您具有两个分区。在此情况下，您可以使用具有 6.05GB 内存的 `cache.m3.large` 节点（12GB/2）。但是，您可能需要更多内存才能执行 `BGSAVE` 操作。如果您的应用程序写入操作繁重，请将内存要求翻倍至至少每个分区 12GB。因此，使用具有 13.3GB 内存的 `cache.m3.xlarge` 或具有 13.5GB 内存的 `cache.r3.large`。
+ 您是否正在使用 Local Zones？
[Local Zones](Local_zones.md) 使您能够将 ElastiCache 集群等资源放置在靠近用户的多个位置。但是，当您选择节点大小时，请注意，无论容量要求如何，本次可用节点大小目前仅限于以下内容：
+ 最新一代：
**M5 节点类型：**、`cache.m5.large`、`cache.m5.xlarge`、`cache.m5.2xlarge`、`cache.m5.4xlarge`、`cache.m5.12xlarge``cache.m5.24xlarge`
**R5 节点类型：**、`cache.r5.large`、`cache.r5.xlarge`、`cache.r5.2xlarge`、`cache.r5.4xlarge`、`cache.r5.12xlarge``cache.r5.24xlarge`
**T3 节点类型：**、`cache.t3.micro`、`cache.t3.small``cache.t3.medium`
您的集群运行期间，您可以监控发布到 CloudWatch 的内存使用率、处理器利用率、缓存命中数和缓存未命中数指标。您可能会注意到您的集群没有您想要的命中率，或者密钥被移出的频率过于频繁。在这些情况下，您可以选择具有较高 CPU 和内存规格的不同节点大小。
监控 CPU 使用情况时，请记住 Valkey 和 Redis OSS 是单线程的。因此，将报告的 CPU 使用率乘以 CPU 核心数来获得实际使用量。例如，报告的使用率为 20% 的四核 CPU 实际上相当于一个使用率为 80% 的单核 Redis OSS。
## 节点大小（Memcached）
Memcached 集群包含一个或多个节点，该集群的数据会分区到各个节点中。因此，集群的内存需求和节点的内存相关但不相同。您可以通过拥有几个大型节点或多个小型节点来获得所需的集群内存容量。此外，由于您的需求是变化的，您可以在集群中添加节点或删除节点，从而仅为所需内容付费。
集群的总内存容量的计算方法是，在扣除系统开销后将集群中的节点数乘以每个节点的 RAM 容量。每个节点的容量都基于节点类型。
```
cluster_capacity = number_of_nodes * (node_capacity - system_overhead)
```
集群中的节点数是运行 Memcached 的集群可用性的一个关键因素。如果单一节点出现故障，则可能对应用程序的可用性以及后端数据库的负载产生影响。在这种情况下，ElastiCache 会更换出现故障的节点并对其进行重新填充。要减小这种可用性影响，请将内存和计算容量分布于更多节点上（每个节点的容量稍小），而非使用少量大容量节点。
在您希望拥有 35GB 缓存内存的情况下，可以设置以下任意配置：
+ 11 `cache.t2.medium` 个节点，每个节点具有 3.22 GB 内存和 2 个线程，共 35.42 GB 和 22 个线程。
+ 6 `cache.m4.large` 个节点，每个节点具有 6.42 GB 内存和 2 个线程，共 38.52 GB 和 12 个线程。
+ 3 `cache.r4.large` 个节点，每个节点具有 12.3 GB 内存和 2 个线程，共 36.90 GB 和 6 个线程。
+ 3 `cache.m4.xlarge` 个节点，每个节点具有 14.28 GB 内存和 4 个线程，共 42.84 GB 和 12 个线程。
**比较节点选项**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/CacheNodes.SelectSize.html)
这些选项都提供了类似的内存容量，但提供了不同的计算容量和成本。要比较特定选项的成本，请参阅 [Amazon ElastiCache 定价](https://aws.amazon.com/elasticache/pricing/)。
对于运行 Memcached 的集群，每个节点上的部分可用内存都会用于连接开销。有关更多信息，请参阅 [Memcached 连接开销](ParameterGroups.Engine.md#ParameterGroups.Memcached.Overhead)
使用多个节点需要跨这些节点分布密钥。每个节点都有自己的终端节点。为了便于管理端点，您可以使用 ElastiCache（Auto Discovery 功能）以使客户端程序能够自动标识集群中的所有节点。有关更多信息，请参阅 [自动识别集群（Memcached）中的节点](AutoDiscovery.md)。
在某些情况下，您可能无法确定您需要多少容量。如果是这样，对于测试，我们建议从 `cache.m5.large` 节点开始。然后，使用发布到 Amazon CloudWatch 的 ElastiCache 指标监控内存使用率、CPU 利用率和缓存命中率。有关 ElastiCache 的 CloudWatch 指标的更多信息，请参阅 [使用 CloudWatch 指标监控使用情况](CacheMetrics.md)。对于生产和大型工作负载，R5 节点提供了最佳性能和 RAM 成本价值。
如果您的集群没有所需的命中率，您可以轻松地添加更多的节点，从而增加您的集群的可用内存总量。
如果集群受到 CPU 的约束，但具有足够的命中率，请使用提供更强计算能力的节点类型来设置新集群。
# 创建 Valkey 或 Redis OSS 集群
以下示例展示了如何使用AWS 管理控制台、AWS CLI和 ElastiCache API 创建 Valkey 或 Redis OSS 集群。
## 创建 Valkey 或 Redis OSS 集群（已禁用集群模式）集群（控制台）
ElastiCache 当你使用 Valkey 或 Redis OSS 引擎时，支持复制。要监控数据写入 Valkey 或 Redis OSS read/write 主集群与数据传播到只读辅助集群之间的延迟，请向集群 ElastiCache 添加一个特殊密钥。`ElastiCacheMasterReplicationTimestamp`此键为当前世界时（UTC）时间。因为 Valkey 或 Redis OSS 集群可能会在以后添加到复制组中，所以此键包含在所有 Valkey 或 Redis OSS 集群中，即使它们最初不是复制组的成员也会如此。有关复制组的更多信息，请参阅[使用复制组时的高可用性](Replication.md)。
要创建 Valkey 或 Redis OSS（已禁用集群模式）集群，请按照 [创建 Valkey（已禁用集群模式）集群（控制台）](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs) 中的步骤操作。
一旦您的集群状态变为*可用*，您就可以向 Amazon 授予 EC2 访问权限、连接集群并开始使用它。有关更多信息，请参阅[步骤 3：授予对集群的访问权限](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey)和[步骤 4：连接到集群的节点](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey)。
**重要**
一旦您的集群变为可用状态，您便需要为集群处于活动状态的每个小时或分钟支付费用（即使您并未主动使用集群）。要停止此集群产生的费用，您必须将其删除。请参阅[删除中的集群 ElastiCache](Clusters.Delete.md)。
## 创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）
如果运行的是 Redis OSS 3.2.4 或更高版本，您可以创建 Redis OSS（已启用集群模式）集群。Valkey 或 Redis OSS（已启用集群模式）集群支持将您的数据分配到 1 到 500 个分片（API/CLI：节点组）上，但存在一些限制。有关 Valkey 或 Redis OSS（已禁用集群模式）和 Valkey 或 Redis OSS（已启用集群模式）的对比，请参阅[支持的引擎和版本](VersionManagement.md#supported-engine-versions)。
**使用控制台创建 Valkey 或 Redis OSS（已启用集群模式）集群 ElastiCache**
1. 登录AWS 管理控制台并打开亚马逊 ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 从右上角的列表中，选择要启动此集群的AWS区域。
1. 从导航窗格中，选择 **Get started**（入门）。
1. 选择 **Create VPC**（创建 VPC）并按照[创建虚拟私有云（VPC）](VPCs.CreatingVPC.md)中的步骤操作。
1. 在 ElastiCache 控制面板页面上，选择**创建集群，然后选择创建** **Valkey 集群或创****建 Redis OSS** 集群。
1. 在 **Cluster settings**（集群设置）下，执行以下操作：
1. 选择 **Configure and create a new cluster**（配置和创建新集群）。
1. 对于 **Cluster mode**（集群模式），选择 **Enabled**（已启用）。
1. 对于 **Cluster info**（集群信息），为 **Name**（名称）输入一个值。
1. （可选）为 **Description**（描述）输入一个值。
1. 在 **Location**（位置）下：
------
#### [ AWS Cloud ]
1. 对于 **AWS Cloud**，我们建议您接受 **Multi-AZ**（多可用区）和 **Auto-failover**（自动失效转移）的默认设置。有关更多信息，请参阅使用[多可用区 ElastiCache 最大限度地缩短 Redis OSS 的停机时间](AutoFailover.md)。
1. 在 **Cluster settings**（集群设置）下
1. 对于 **Engine version**（引擎版本），选择一个可用的引擎版本。
1. 对于 **Port**（端口），使用默认端口 6379。如果您出于某个原因需要使用其他端口，请输入相应的端口号。
1. 对于**参数组**，选择一个参数组或创建一个新参数组。参数组控制集群的运行时参数。有关参数组的更多信息，请参阅[Valkey 和 Redis OSS 参数](ParameterGroups.Engine.md#ParameterGroups.Redis) 和[创建 ElastiCache 参数组](ParameterGroups.Creating.md)。
**注意**
当您选择要设置引擎配置值的参数组时，该参数组将应用于全局数据存储中的所有集群。在 **Parameter Groups（参数组）**页面上，是/否 **Global（全局）**属性指示参数组是否属于全局数据存储。
1. 对于 **Node type（节点类型）**，请选择向下箭头（![\[Downward-pointing triangle icon, typically used to indicate a dropdown menu.\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-DnArrow.png)）。在 **Change node type（更改节点类型）**对话框中，为所需节点类型选择 **Instance family（实例系列）**值。接着选择要用于此集群的节点类型，然后选择**保存**。
有关更多信息，请参阅 [选择节点大小](CacheNodes.SelectSize.md)。
如果您选择 r6gd 节点类型，则系统会自动启用数据分层。有关更多信息，请参阅 [ElastiCache 中的数据分层](data-tiering.md)。
1. 对于**分片数**，选择要用于此 Valkey 或 Redis OSS（已启用集群模式）集群的分片（分区/节点组）数。
对于某些版本的 Valkey 或 Redis OSS（已启用集群模式），您可以动态更改集群中的分片数量：
+ **Redis OSS 3.2.10 及更高版本** – 如果您的集群运行 Redis OSS 3.2.10 或更高版本，则可以动态更改集群中的分片数量。有关更多信息，请参阅 [扩缩 Valkey 或 Redis OSS（已启用集群模式）集群](scaling-redis-cluster-mode-enabled.md)。
+ **其他 Redis OSS 版本** – 如果您的集群正在运行 3.2.10 版之前的 Redis OSS 版本，则还有另一种方法。在这种情况下，要更改集群中的分片数量，请使用新分片数量创建一个新集群。有关更多信息，请参阅 [从备份还原到新缓存](backups-restoring.md)。
1. 对于**每个分片的副本数量**，请选择每个分片中需要的只读副本节点数。
Valkey 或 Redis OSS（已启用集群模式）存在以下限制。
+ 如果启用了多可用区，请确保每个分片至少有一个副本。
+ 使用控制台创建集群时，每个分片的副本数相同。
+ 每个分片的只读副本数固定，无法更改。如果您需要增加或减少各分片（API/CLI：节点组）的副本数，您必须使用新的副本数量创建一个新集群。有关更多信息，请参阅 [教程：使用外部创建的备份为新的基于节点的集群制作种子](backups-seeding-redis.md)。
1. 在 **Connectivity**（连接）下
1. 对于 **Network type**（网络类型），选择此集群将支持的 IP 版本。
1. 对于**子网组**，请选择要应用于此集群的子网。 ElastiCache 使用该子网组选择子网和该子网内的 IP 地址以与您的节点关联。 ElastiCache 群集需要一个双堆栈子网 IPv4 并分配给它们 IPv6 的地址才能在双堆栈模式下运行，并且需要一个 IPv6仅限子网才能以-only模式运行。 IPv6
创建新的子网组时，输入其所属的 **VPC ID**。
选择 **Discovery IP type**（发现 IP 类型）。仅返回所选协议的 IP 地址。
有关更多信息，请参阅:
+ [在中选择网络类型 ElastiCache](network-type.md).
+ [在您的 VPC 中创建子网](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet)。
如果您是 [将 Local Zones 与 ElastiCache 结合使用](Local_zones.md)，则必须创建或选择位于本地区域中的子网。
有关更多信息，请参阅 [子网和子网组](SubnetGroups.md)。
1. 对于 **Availability zone placements**（可用区位置），您有两种选择：
+ **无偏好** — ElastiCache 选择可用区。
+ **Specify availability zones（指定可用区）**– 您为各集群指定可用区。
如果您选择指定可用区，则需从列表中为各分片中的每个集群选择可用区。
有关更多信息，请参阅 [为 ElastiCache 选择区域和可用区](RegionsAndAZs.md)。
1. 选择 **Next**（下一步）
1. 在**高级 Valkey 设置**或**高级 Redis OSS 设置**下或
1. 对于 **Security**（安全）：
1. 要加密您的数据，您有以下选项：
+ **Encryption at rest（静态加密）**– 对磁盘上存储的数据启用加密。有关更多信息，请参阅[静态加密](at-rest-encryption.md)。
**注意**
您可以选择提供不同的加密密钥，方法是选择 “**客户托管AWS KMS 密钥**” 并选择密钥。有关更多信息，请参阅[使用AWS KMS 客户自主管理型密钥](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security)。
+ **Encryption in-transit（传输中加密）**– 对传输中数据启用加密。有关更多信息，请参阅[传输中加密](in-transit-encryption.md)。对于 Valkey 7.2 及更高版本或 Redis OSS 6.0 及更高版本，如果您启用传输中加密，则系统会提示您指定以下**访问控制**选项之一：
+ **No Access Control（无访问控制）**– 此选项为默认设置。这表示对用户访问集群的权限没有任何限制。
+ **User Group Access Control List（用户组访问控制列表）**– 选择具有集群访问权限的已定义用户组。有关更多信息，请参阅 [使用控制台和 CLI 管理用户组](Clusters.RBAC.md#User-Groups)。
+ **Redis AUTH 默认用户** – Valkey 或 Redis OSS 服务器的身份验证机制。有关更多信息，请参阅 [AUTH](auth.md)。
+ **AUTH** – Valkey 或 Redis OSS 服务器的身份验证机制。有关更多信息，请参阅 [AUTH](auth.md)。
**注意**
对于 Redis OSS 3.2.6 及更高版本（版本 3.2.10 除外），只能选择 AUTH。
1. 对于**安全组**，选择要用于该集群的安全组。*安全组* 充当防火墙来控制对集群的网络访问。您可以为 VPC 使用默认安全组或创建新安全组。
有关安全组的更多信息，请参阅 *Amazon VPC 用户指南*中的[您的 VPC 的安全组](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)。
1. 如果需要定期计划自动备份，请选择**启用自动备份**，然后输入每个自动备份在被自动删除前保留的天数。如果您不希望定期计划自动备份，请清除 **Enable automatic backups** 复选框。不论是哪种情况，您始终可以选择创建手动备份。
有关备份和还原的更多信息，请参阅[快照和还原](backups.md)。
1. （可选）指定维护时段。*维护时段* 是每周中 ElastiCache 为您的集群计划系统维护的时间，通常以小时为时间长度。您可以允许 ElastiCache 选择维护时段的日期和时间（*No preference (无首选项)*），或者自行选择日期、时间和持续时间（*Specify maintenance window (指定维护时段)*）。如果您从列表中选择了*指定维护时段*，请为您的维护时段选择*开始日期*、*开始时间*和*持续时间*（以小时为单位）。所有时间均为 UCT 时间。
有关更多信息，请参阅 [管理 ElastiCache 集群维护](maintenance-window.md)。
1. （可选）对于 **Logs（日志）**：
+ 在 **Log format（日志格式）**下，选择 **Text（文本）**或 **JSON**。
+ 在**目标类型**下，选择**CloudWatch 日志**或 **Kinesis Fire** hose。
+ 在 “**日志目标**” 下，选择 “**新建**” 并输入您的 CloudWatch 日志日志组名称或 Firehose 直播名称，或者选择 **“选择现有”**，然后选择您的 CloudWatch 日志日志组名称或 Firehose 直播名称，
1. 对于**标签**，为了帮助您管理集群和其他 ElastiCache 资源，您可以以标签的形式为每个资源分配自己的元数据。有关更多信息，请参阅 [为资源添加 ElastiCache 标签](Tagging-Resources.md)。
1. 选择 **Next**（下一步）。
1. 查看您的所有输入和选择，然后进行任意所需的更正。当您准备好后，选择 **Create**（创建）。
------
#### [ On premises ]
1. 对于 **On premises**（本地），我们建议您保留 **Auto-failover**（自动失效转移）为启用状态。有关更多信息，请参阅使用多可用[区 ElastiCache 最大限度地缩短 Redis OSS 的停机时间](AutoFailover.md)
1. 按照[使用 Outposts](ElastiCache-Outposts.md) 中的步骤操作。
------
要使用 ElastiCache API 或AWS CLI代替 ElastiCache 控制台创建等效项，请参阅以下内容：
+ API：[CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI：[create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
一旦集群的状态变为*可用*，您就可以授予对其的 EC2 访问权限、连接到集群并开始使用它。有关更多信息，请参阅[步骤 3：授予对集群的访问权限](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey)和[步骤 4：连接到集群的节点](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey)。
**重要**
一旦您的集群变为可用状态，您便需要为集群处于活动状态的每个小时或分钟支付费用（即使您并未主动使用集群）。要停止此集群产生的费用，您必须将其删除。请参阅 [删除中的集群 ElastiCache](Clusters.Delete.md)。
## 创建集群（AWS CLI）
要使用创建集群AWS CLI，请使用`create-cache-cluster`命令。
**重要**
一旦您的集群变为可用状态，您便需要为集群处于活动状态的每个小时或分钟支付费用（即使您并未主动使用集群）。要停止此集群产生的费用，您必须将其删除。请参阅[删除中的集群 ElastiCache](Clusters.Delete.md)。
### 创建 Redis OSS（已禁用集群模式）集群（CLI）
**Example – 一个无只读副本的 Valkey 或 Redis OSS（已禁用集群模式）集群**
下面的 CLI 代码将创建一个无副本的 Valkey 或 Redis OSS（已禁用集群模式）集群。
使用 r6gd 系列的节点类型创建集群时，必须传递 `data-tiering-enabled` 参数。
对于 Linux、macOS 或 Unix：
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine redis \
--num-cache-nodes 1 \
--cache-parameter-group default.redis6.x \
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
对于 Windows：
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine redis ^
--num-cache-nodes 1 ^
--cache-parameter-group default.redis6.x ^
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
### 创建 Valkey 或 Redis OSS（已启用集群模式）集群（AWS CLI）
Valkey 或 Redis OSS（已启用集群模式）集群（API/CLI：复制组）不能使用 `create-cache-cluster` 操作创建。要创建 Valkey 或 Redis OSS（已启用集群模式）集群（API/CLI：复制组），请参阅[从头开始创建 Valkey 或 Redis OSS（已启用集群模式）复制组（AWS CLI）](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI)。
有关更多信息，AWS CLI请参阅 ElastiCache 参考主题[https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)。
## 为 Valkey 或 Redis OSS 创建集群 (API) ElastiCache
要使用 ElastiCache API 创建集群，请使用`CreateCacheCluster`操作。
**重要**
一旦您的集群变为可用状态，您便需要为集群处于活动状态的每个小时或分钟支付费用（即使您并未使用集群）。要停止此集群产生的费用，您必须将其删除。请参阅[删除中的集群 ElastiCache](Clusters.Delete.md)。
**Topics**
+ [创建 Valkey 或 Redis OSS（已禁用集群模式）集群 (ElastiCache API)](#Clusters.Create.API.Redis)
+ [在 Valkey 或 Redis OSS 中创建集群（已启用集群模式）(ElastiCache API)](#Clusters.Create.API.RedisCluster)
### 创建 Valkey 或 Redis OSS（已禁用集群模式）集群 (ElastiCache API)
以下代码创建一个 Valkey 或 Redis OSS（已禁用集群模式）集群 (ElastiCache API)。
添加换行符以便于阅读。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&CacheParameterGroup=default.redis3.2
&Engine=redis
&EngineVersion=3.2.4
&NumCacheNodes=1
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&SnapshotArns.member.1=arn%3Aaws%3As3%3A%3A%3AmyS3Bucket%2Fdump.rdb
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
### 在 Valkey 或 Redis OSS 中创建集群（已启用集群模式）(ElastiCache API)
Valkey 或 Redis OSS（已启用集群模式）集群（API/CLI：复制组）不能使用 `CreateCacheCluster` 操作创建。要创建 Valkey 或 Redis OSS（已启用集群模式）集群（API/CLI：复制组），请参阅[从头开始在 Valkey 或 Redis OSS（已启用集群模式）中创建复制组（ElastiCache API）](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.API)。
有关更多信息，请参阅 ElastiCache API 参考主题[https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)。
# 为 Memcached 创建集群
以下示例说明如何使用AWS 管理控制台、AWS CLI和 ElastiCache API 创建集群。
## 创建 Memcached 集群（控制台）
当您使用 Memcached 引擎时，Amazon ElastiCache 支持在多个节点上水平分区您的数据。Memcached 支持 Auto Discovery，因此您无需跟踪每个节点的终端节点。Memcached 跟踪每个节点的终端节点，并在添加和删除节点时更新终端节点列表。您的应用程序需要与集群进行的所有交互都在配置终端节点上进行。
要通过控制台创建 Memcached 集群，请按照[创建 Valkey（已禁用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster)中的步骤操作。进入第五步后，选择**创建 Memcached 缓存**。
一旦您的集群状态变为*可用*，您就可以授予 Amazon 对其的 EC2 访问权限、连接该集群并开始使用它。有关类似步骤的更多信息，请参阅[步骤 3：授予对集群的访问权限](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey)和[步骤 4：连接到集群的节点](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey)。
**重要**
一旦您的集群变为可用状态，您便需要为集群处于活动状态的每个小时或分钟支付费用（即使您并未主动使用集群）。要停止此集群产生的费用，您必须将其删除。请参阅 [删除中的集群 ElastiCache](Clusters.Delete.md)。
## 创建集群（AWS CLI）
要使用创建集群AWS CLI，请使用`create-cache-cluster`命令。
**重要**
一旦您的集群变为可用状态，您便需要为集群处于活动状态的每个小时或分钟支付费用（即使您并未主动使用集群）。要停止此集群产生的费用，您必须将其删除。请参阅[删除中的集群 ElastiCache](Clusters.Delete.md)。
### 创建 Memcached 缓存群集 (AWS CLI)
下面的 CLI 代码将创建一个具有 3 个节点的 Memcached 集群。
对于 Linux、macOS 或 Unix：
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine memcached \
--engine-version 1.4.24 \
--cache-parameter-group default.memcached1.4 \
--num-cache-nodes 3
```
对于 Windows：
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine memcached ^
--engine-version 1.4.24 ^
--cache-parameter-group default.memcached1.4 ^
--num-cache-nodes 3
```
## 为 Memcached 创建集群 (ElastiCache API)
要使用 ElastiCache API 创建集群，请使用`CreateCacheCluster`操作。
**重要**
一旦您的集群变为可用状态，您便需要为集群处于活动状态的每个小时或分钟支付费用（即使您并未使用集群）。要停止此集群产生的费用，您必须将其删除。请参阅[删除中的集群 ElastiCache](Clusters.Delete.md)。
**Topics**
+ [创建 Memcached 集群 (ElastiCache API)](#Clusters.Create.API.Memcached)
### 创建 Memcached 集群 (ElastiCache API)
以下代码创建了一个包含 3 个节点 (ElastiCache API) 的 Memcached 集群。
添加换行符以便于阅读。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&Engine=memcached
&NumCacheNodes=3
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
# 查看 ElastiCache 集群的详细信息
您可以使用 ElastiCache 控制台、AWS CLI 或 ElastiCache API 查看有关一个或多个集群的详细信息。
## 查看 Memcached 集群的详细信息（控制台）
您可以使用 ElastiCache 控制台、AWS CLI for ElastiCache，或 ElastiCache API 查看 Memcached 集群的详细信息。
以下过程详细说明了如何使用 ElastiCache 控制台查看 Memcached 集群的详细信息。
**查看 Memcached 集群的详细信息**
1. 登录 AWS 管理控制台 并打开 Amazon ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 从右上角的列表中，选择您感兴趣的 AWS 区域。
1. 在 ElastiCache 引擎控制面板中，选择 **Memcached**。这将显示在 Memcached 引擎上运行的所有集群列表。
1. 要查看集群的详细信息，请选择集群名称左侧的复选框。
1. 要查看节点信息，请选择 **Nodes**（节点）选项卡，该选项卡显示有关节点状态和端点的信息。
1. 要查看指标，请选择 **Metrics**（指标）选项卡，该选项卡显示集群中所有节点的相关指标。有关更多信息，请参阅 [使用 CloudWatch 指标监控使用情况](CacheMetrics.md)。
1. 选择 **Network and security**（网络和安全）选项卡，可查看有关集群的网络连接和子网组配置以及 VPC 安全组的详细信息。有关更多信息，请参阅 [子网和子网组](SubnetGroups.md)。
1. 选择 **Maintenance**（维护）选项卡，可查看有关集群维护设置的详细信息。有关更多信息，请参阅 [管理 ElastiCache 集群维护](maintenance-window.md)。
1. 选择 **Tags**（标签）选项卡，可查看应用于集群资源的任何标签的详细信息。有关更多信息，请参阅 [为资源添加 ElastiCache 标签](Tagging-Resources.md)。
## 查看 Valkey 或 Redis OSS（已禁用集群模式）详细信息（控制台）
您可以使用 ElastiCache 控制台、AWS CLI for ElastiCache，或 ElastiCache API 查看 Valkey 或 Redis OSS（已禁用集群模式）集群的详细信息。
以下过程详细说明了如何使用 ElastiCache 控制台查看 Valkey 或 Redis OSS（已禁用集群模式）集群的详细信息。
**查看 Valkey 或 Redis OSS（已禁用集群模式）集群的详细信息**
1. 登录 AWS 管理控制台 并打开 Amazon ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 在 ElastiCache 引擎控制面板中，选择 **Valkey** 或 **Redis OSS** 以显示在该引擎上运行的所有集群的列表。
1. 要查看集群的详细信息，请选择集群名称左侧的复选框。确保所选的集群运行 Valkey 或 Redis OSS 引擎，而不是 Clustered Valkey 或 Clustered Redis OSS。执行此操作将显示该集群的详细信息，包括集群的主端点。
1. 查看节点信息：
1. 选择集群的名称。
1. 选择 **Shards and nodes**（分片和节点）选项卡。执行此操作将显示每个节点的详细信息，包括节点中用于从集群进行读取的端点。
1. 要查看指标，请选择 **Metrics**（指标）选项卡，该选项卡显示集群中所有节点的相关指标。有关更多信息，请参阅 [使用 CloudWatch 指标监控使用情况](CacheMetrics.md)。
1. 要查看日志，请选择 **Logs**（日志）选项卡，该选项卡指示集群使用的是慢日志还是引擎日志，并提供相关详细信息。有关更多信息，请参阅 [日志传输](Log_Delivery.md)。
1. 选择 **Network and security**（网络和安全）选项卡，可查看有关集群的网络连接和子网组配置的详细信息。有关更多信息，请参阅 [子网和子网组](SubnetGroups.md)。
1. 选择 **Maintenance**（维护）选项卡，可查看有关集群维护设置的详细信息。有关更多信息，请参阅 [管理 ElastiCache 集群维护](maintenance-window.md)。
1. 选择 **Service updates**（服务更新）选项卡，可查看所有可用服务更新的详细信息及其建议的应用截止日期。有关更多信息，请参阅 [中的服务更新 ElastiCache](Self-Service-Updates.md)。
1. 选择 **Tags**（标签）选项卡，可查看应用于集群资源的任何标签的详细信息。有关更多信息，请参阅 [为资源添加 ElastiCache 标签](Tagging-Resources.md)。
## 查看 Valkey 或 Redis OSS（已启用集群模式）集群的详细信息（控制台）
您可以使用 ElastiCache 控制台、AWS CLI for ElastiCache，或 ElastiCache API 查看 Valkey 或 Redis OSS（已启用集群模式）集群的详细信息。
以下过程详细说明了如何使用 ElastiCache 控制台查看 Valkey 或 Redis OSS（已启用集群模式）集群的详细信息。
**查看 Valkey 或 Redis OSS（已启用集群模式）集群的详细信息**
1. 登录 AWS 管理控制台 并打开 Amazon ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 从右上角的列表中，选择您感兴趣的 AWS 区域。
1. 在 ElastiCache 引擎控制面板中，选择 **Valkey** 或 **Redis OSS** 以显示在该引擎上运行的所有集群的列表。
1. 要查看 Valkey 或 Redis OSS（已启用集群模式）集群的详细信息，请选择集群名称左侧的复选框。确保您选择的是运行 Valkey 或 Clustered Redis OSS 引擎的集群。
该集群下方的屏幕会扩展，显示有关该集群的详细信息，包括该集群的配置端点。
1. 要查看集群分片的列表及每个分片的节点数量，请选择 **Shards and nodes**（分片和节点）选项卡。
1. 查看有关节点的特定信息：
1. 选择分片的 ID。
这将显示有关每个节点的信息，包括用于从集群中读取数据的每个节点的端点。
1. 要查看指标，请选择 **Metrics**（指标）选项卡，该选项卡显示集群中所有节点的相关指标。有关更多信息，请参阅 [使用 CloudWatch 指标监控使用情况](CacheMetrics.md)。
1. 要查看日志，请选择 **Logs**（日志）选项卡，该选项卡指示集群使用的是慢日志还是引擎日志，并提供相关详细信息。有关更多信息，请参阅 [日志传输](Log_Delivery.md)。
1. 选择 **Network and security**（网络和安全）选项卡，可查看有关集群的网络连接和子网组配置、VPC 安全组以及集群上启用的加密方法（如有）的详细信息。有关更多信息，请参阅[子网和子网组](SubnetGroups.md)和[Amazon ElastiCache 中的数据安全性](encryption.md)。
1. 选择 **Maintenance**（维护）选项卡，可查看有关集群维护设置的详细信息。有关更多信息，请参阅 [管理 ElastiCache 集群维护](maintenance-window.md)。
1. 选择 **Service updates**（服务更新）选项卡，可查看所有可用服务更新的详细信息及其建议的应用截止日期。有关更多信息，请参阅 [中的服务更新 ElastiCache](Self-Service-Updates.md)。
1. 选择 **Tags**（标签）选项卡，可查看应用于集群资源的任何标签的详细信息。有关更多信息，请参阅 [为资源添加 ElastiCache 标签](Tagging-Resources.md)。
## 查看 ElastiCache 集群的详细信息（AWS CLI）
以下代码列出 *my-cluster* 的详细信息：
```
aws elasticache describe-cache-clusters --cache-cluster-id my-cluster
```
如果使用 `create-cache-cluster` 命令创建具有 1 个缓存节点和 0 个分片的集群，请用集群的名称替换 *my-cluster*。
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"Engine": "redis",
"PreferredMaintenanceWindow": "wed:12:00-wed:13:00",
"CacheSubnetGroupName": "default",
"SnapshotWindow": "08:30-09:30",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"CacheClusterId": "my-cluster1",
"CacheClusterCreateTime": "2018-02-26T21:06:43.420Z",
"PreferredAvailabilityZone": "us-west-2c",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"AutoMinorVersionUpgrade": true,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
]
}
```
如果使用 AWS 管理控制台创建集群（启用或禁用集群节点，具有一个或多个分片），请使用以下命令描述集群的详细信息 [将 *my-cluster* 替换为复制组的名称（集群的名称）]：
```
aws elasticache describe-replication-groups --replication-group-id my-cluster
```
有关更多信息，请参阅 AWS CLI for ElastiCache 主题 [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html)。
## 查看 ElastiCache 集群的详细信息（ElastiCache API）
您可以使用 ElastiCache API `DescribeCacheClusters` 操作查看集群的详细信息。如果包含 `CacheClusterId` 参数，则将返回指定的集群的详细信息。如果省略 `CacheClusterId` 参数，则会返回最多 `MaxRecords` 个（默认 100 个）集群的详细信息。`MaxRecords` 的值不能小于 20 或大于 100。
以下代码列出了 `my-cluster` 的详细信息。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=my-cluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
以下代码列出了最多 25 个集群的详细信息。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&MaxRecords=25
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
有关更多信息，请参阅 ElastiCache API 参考主题 [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html)。
# 修改 ElastiCache 集群
除了向 ElastiCache 集群添加或从中移除节点外，有时您可能还需要做出其他更改，如添加安全组、更改维护时段或参数组。
我们建议您将维护时段设置在使用率最低的时间内。因此，维护时段需要不时进行修改。
在更改集群的参数时，所做的更改将立即或在重新启动集群后应用于集群。无论是更改集群的参数组本身还是更改集群参数组中的参数值，都是如此。要确定何时应用特定的参数更改，请参阅[Memcached 特定的参数](ParameterGroups.Engine.md#ParameterGroups.Memcached)和[Valkey 和 Redis OSS 参数](ParameterGroups.Engine.md#ParameterGroups.Redis)的表中**详细信息**列的**更改生效**部分。有关重启集群节点的信息，请参阅 [重启节点](nodes.rebooting.md)。
## 使用 ElastiCache AWS 管理控制台
**修改集群**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 从右上角的列表中，选择要修改的集群所在的 AWS 区域。
1. 在导航窗格中，选择在您要修改的集群上运行的引擎。
此时会显示选定引擎的集群列表。
1. 在集群列表中，对于要修改的集群，选择其名称。
1. 选择 **Actions**（操作），然后选择 **Modify**（修改）。
**Modify Cluster**（修改集群）窗口随即出现。
1. 在**修改集群**窗口中，根据需要做出修改。选项包括：
+ 描述
+ 集群模式 - 要将集群模式从**已禁用**修改为**已启用**，必须先将集群模式设置为**兼容**。
兼容模式让 Valkey 或 Redis 客户端在启用集群模式和禁用集群模式的情况下都能进行连接。在将所有 Valkey 或 Redis OSS 客户端迁移到使用**已启用**集群模式后，就可以完成集群模式配置并将集群模式设置为已启用。
+ 引擎版本兼容性
**重要**
您可以升级到较新的引擎版本。升级主要引擎版本（例如从 5.0.6 升级到 6.0）时，您需要选择一个与新引擎版本兼容的参数组系列。有关执行此操作的更多信息，请参阅 [的版本管理 ElastiCache](VersionManagement.md)。不过，您不能降级到较早的引擎版本，除非删除现有集群并重新创建它。
+ VPC 安全组
+ 参数组
+ 节点类型
**注意**
如果集群使用 r6gd 系列的节点类型，则只能选择该系列中的不同节点大小。如果您选择 r6gd 系列的节点类型，则系统会自动启用数据分层。有关更多信息，请参阅[数据分层](data-tiering.md)。
+ 多可用区
+ 自动故障转移（仅限已禁用集群模式）
+ 启用自动备份
+ 备份节点 ID
+ 备份保留期
+ 备份时段
+ SNS 主题通知
+ Memcached 引擎版本兼容性
+ 网络类型
**注意**
如果要从 IPv4 切换到 IPv6，则必须选择或创建与 IPv6 兼容的子网组。有关更多信息，请参阅 [在中选择网络类型 ElastiCache](network-type.md)。
+ VPC 安全组
+ 参数组
+ 维护时段
+ SNS 主题通知
**立即应用**框仅适用于修改引擎版本和节点类型。要立即应用更改，请选中 **Apply Immediately**（立即应用）复选框。如果未选中此框，则将在下一维护时段内应用引擎版本修改。诸如更改维护时段这样的其他修改是立即应用的。
**为 Redis 启用/禁用日志传输**
1. 从集群列表中，选择要修改的集群。选择 **Cluster name（集群名称）**而不是旁边的复选框。
1. 在**集群详细信息**页面上，选择**日志**选项卡。
1. 要启用或禁用慢日志，请选择**启用**或**禁用**。
如果您选择启用：
1. 在 **Log format**（日志格式）下，选择 **JSON** 或 **Text**（文本）。
1. 在 **Log destination type**（日志目标类型）下，选择 **CloudWatch Logs** 或 **Kinesis Firehose**。
1. 在**日志目标**下，您可以选择**新建**，然后输入您的 CloudWatch Logs 日志组名称或 Kinesis Data Firehose 流名称。您也可以选择**选择现有**，然后选择您的 CloudWatch Logs 日志组名称或 Kinesis Data Firehose 流名称。
1. 请选择**启用**。
**要更改 Redis 的配置：**
1. 选择**修改**。
1. 在 **Log format**（日志格式）下，选择 **JSON** 或 **Text**（文本）。
1. 在 **Destination Type**（目标类型）下，选择 **CloudWatch Logs** 或 **Kinesis Firehose**。
1. 在 **Log destination**（日志目标）下，选择 **Create new**（新建），然后输入您的 CloudWatchLogs 日志组名称或 Kinesis Data Firehose 流名称。或者选择 **Select existing**（选择现有），然后选择您的 CloudWatchLogs 日志组名称或 Kinesis Data Firehose 流名称。
## 使用 ElastiCache AWS CLI
您可以使用 AWS CLI `modify-cache-cluster` 操作修改现有集群。要修改集群的配置值，请指定集群的 ID、要更改的参数和此参数的新值。以下示例更改名为 `my-cluster` 的集群的维护时段，并立即应用此更改。
**重要**
您可以升级到较新的 Memcached 引擎版本。有关执行此操作的更多信息，请参阅 [的版本管理 ElastiCache](VersionManagement.md)。不过，您不能降级到较早的引擎版本，除非删除现有集群并重新创建它。
**重要**
您可以升级到较新的 Valkey 或 Redis OSS 引擎版本。升级主要引擎版本（例如从 Redis OSS 5.0.6 升级到 Redis OSS 6.0）时，您需要选择一个与新引擎版本兼容的参数组系列。有关执行此操作的更多信息，请参阅 [的版本管理 ElastiCache](VersionManagement.md)。不过，您不能降级到较早的引擎版本，除非删除现有集群并重新创建它。
对于 Linux、macOS 或 Unix：
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
对于 Windows：
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
`--apply-immediately` 参数仅适用于节点类型、引擎版本的修改，并更改集群中的节点数。如果您希望立即应用任意这些更改，请使用 `--apply-immediately` 参数。如果您希望将这些更改推迟到下一维护时段，请使用 `--no-apply-immediately` 参数。诸如更改维护时段这样的其他修改是立即应用的。
有关更多信息，请参阅 AWS CLI for ElastiCache 主题 [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html)。
## 使用 ElastiCache API
您可以使用 ElastiCache API `ModifyCacheCluster` 操作修改现有集群。要修改集群的配置值，请指定集群的 ID、要更改的参数和此参数的新值。以下示例更改名为 `my-cluster` 的集群的维护时段，并立即应用此更改。
**重要**
您可以升级到较新的 Memcached 引擎版本。有关执行此操作的更多信息，请参阅 [的版本管理 ElastiCache](VersionManagement.md)。不过，您不能降级到较早的引擎版本，除非删除现有集群并重新创建它。
**重要**
您可以升级到较新的 Valkey 或 Redis OSS 引擎版本。升级主要引擎版本（例如从 Redis OSS 5.0.6 升级到 Redis OSS 6.0）时，您需要选择一个与新引擎版本兼容的参数组系列。有关执行此操作的更多信息，请参阅 [的版本管理 ElastiCache](VersionManagement.md)。不过，您不能降级到较早的引擎版本，除非删除现有集群并重新创建它。
添加换行符以便于阅读。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150901T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150901T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
`ApplyImmediately` 参数仅适用于节点类型、引擎版本的修改，并更改集群中的节点数。如果您希望立即应用任意这些更改，请将 `ApplyImmediately` 参数设置为 `true`。如果您希望将这些更改推迟到下一维护时段，请将 `ApplyImmediately` 参数设置为 `false`。诸如更改维护时段这样的其他修改是立即应用的。
有关更多信息，请参阅 ElastiCache API 参考主题 [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html)。
# 向 ElastiCache 集群添加节点
向 Memcached 集群添加节点会增加您集群的分区数量。更改集群中的分区数量时，需要重新映射一些键空间，以将其映射到正确的节点。重新映射键空间会暂时增加集群上的缓存未命中次数。有关更多信息，请参阅 [配置您的 ElastiCache 客户端以实现高效的负载平衡 (Memcached)](BestPractices.LoadBalancing.md)。
要重新配置 Valkey 或 Redis OSS（已启用集群模式）集群，请参阅[扩缩 Valkey 或 Redis OSS（已启用集群模式）集群](scaling-redis-cluster-mode-enabled.md)
您可以使用 ElastiCache 管理控制台、AWS CLI或 ElastiCache API 向集群添加节点。
## 使用 ElastiCache AWS 管理控制台
将节点添加到单节点 Valkey 或 Redis OSS（已禁用集群模式）集群（未启用复制的集群）是包含两个步骤的流程：首先添加复制，然后添加副本节点。
**主题**
+ [向没有分片的 Valkey 或 Redis OSS 集群添加复制](#AddReplication.CON)
+ [向 ElastiCache 集群添加节点（控制台）](#AddNode.CON)
下面的过程可向未启用复制的单节点 Valkey 或 Redis OSS 添加复制。在添加复制时，现有的节点将成为启用复制的集群中的主节点。添加复制后，您可以向该集群添加最多 5 个副本节点。
**向没有分片的 Valkey 或 Redis OSS 集群添加复制**
1. 登录AWS 管理控制台并打开 ElastiCache 控制台，网址为[ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 在导航窗格中，选择 **Valkey 集群**或 **Redis OSS 集群**。
此时会显示运行引擎的集群列表。
1. 选择要将节点添加到的集群的名称，而不是集群名称左侧的框。
未启用复制的 Redis OSS 集群满足以下条件：
+ 它运行的是 Redis OSS，而不是启用集群模式的 Redis OSS。
+ 它有零个分片。
如果该集群有任何分片、已启用复制，则您可以在[向 ElastiCache 集群添加节点（控制台）](#AddNode.CON)处继续。
1. 选择 **Add replication**。
1. 在**添加复制**中，为该启用复制的集群输入说明。
1. 选择**添加**。
一旦该集群的状态恢复为 *available*，您就可以在下一个流程中继续，并向该集群中添加副本。
**向 ElastiCache 集群添加节点（控制台）**
以下步骤可用于将节点添加到集群。
1. 登录AWS 管理控制台并打开 ElastiCache 控制台，网址为[ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 在导航窗格中，选择在您要添加节点的集群上运行的引擎。
此时会显示运行所选引擎的集群的列表。
1. 从集群列表中，对于要向其添加节点的集群，选择其名称。
如果您的集群是 Valkey 或 Redis OSS（已启用集群模式）集群，请参阅 [扩缩 Valkey 或 Redis OSS（已启用集群模式）集群](scaling-redis-cluster-mode-enabled.md)。
如果您的集群是具有零个分片的 Valkey 或 Redis OSS（已禁用集群模式）集群，请先完成 [向没有分片的 Valkey 或 Redis OSS 集群添加复制](#AddReplication.CON) 中的步骤。
1. 选择 **Add node**。
1. 在 **Add Node (添加节点)** 对话框中，填写请求的信息。
1. 选择 **Apply Immediately - Yes (立即应用 - 是)** 按钮立即添加此节点，或选择 **No (否)** 在集群的下一个维护时段添加此节点。
**新添加和删除请求对待处理请求的影响**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/Clusters.AddNode.html)
要确定哪些操作处于待处理状态，请选择 **Description（描述）**选项卡，然后查看显示了多少待处理的创建或删除操作。您不能同时拥有待处理的创建操作和待处理的删除操作。
1. 选择 **Add** 按钮。
片刻之后，新的节点应会出现在节点列表中，其状态为 **creating**。若非如此，请刷新浏览器页面。当节点的状态更改为 *available* 时，便可以使用新节点。
## 使用 wit AWS CLI h ElastiCache
要使用向集群添加节点AWS CLI，请使用`modify-cache-cluster`带有以下参数的AWS CLI操作：
+ `--cache-cluster-id` 要将节点添加到的集群的 ID。
+ `--num-cache-nodes` `--num-cache-nodes` 参数指定应用修改后此集群中应有的节点的数量。要向此集群添加节点，`--num-cache-nodes` 必须大于此集群中的当前节点数。如果此值小于当前节点数，则 ElastiCache 需要参数`cache-node-ids-to-remove`和要从集群中移除的节点列表。有关更多信息，请参阅 [使用 wit AWS CLI h ElastiCache](Clusters.DeleteNode.md#Clusters.DeleteNode.CLI)。
+ `--apply-immediately` 或 `--no-apply-immediately`，用于指定是立即添加这些节点还是在下一维护时段添加这些节点。
对于 Linux、macOS 或 Unix：
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--num-cache-nodes 5 \
--apply-immediately
```
对于 Windows：
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--num-cache-nodes 5 ^
--apply-immediately
```
此操作将生成类似于以下内容的输出（JSON 格式）：
```
{
"CacheCluster": {
"Engine": "memcached",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "my-cluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "rlh-mem000.7alc7bf-example.cfg.usw2.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-21T16:28:28.973Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "modifying",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {
"NumCacheNodes": 5
},
"PreferredMaintenanceWindow": "sat:09:00-sat:10:00",
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
}
}
```
有关更多信息，请参阅AWS CLI主题[https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html)。
## 使用 wit AWS CLI h ElastiCache
如果要向未启用复制的现有 Valkey 或 Redis OSS（已禁用集群模式）集群添加节点，则必须先创建将该现有集群指定为主集群的复制组。有关更多信息，请参阅 [使用可用 Valkey 或 Redis OSS 集群创建复制组（AWS CLI）](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.CLI)。待该复制组为 *available*（可用）后，您可以继续下面的流程。
要使用向集群添加节点AWS CLI，请使用`increase-replica-count`带有以下参数的AWS CLI操作：
+ `--replication-group-id` 要添加节点的复制组的 ID。
+ `--new-replica-count` 指定应用修改后此复制组中应有的节点的数量。要向此集群添加节点，`--new-replica-count` 必须大于此集群中的当前节点数。
+ `--apply-immediately` 或 `--no-apply-immediately`，用于指定是立即添加这些节点还是在下一维护时段添加这些节点。
对于 Linux、macOS 或 Unix：
```
aws elasticache increase-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 4 \
--apply-immediately
```
对于 Windows：
```
aws elasticache increase-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 4 ^
--apply-immediately
```
此操作将生成类似于以下内容的输出（JSON 格式）：
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test",
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
有关更多信息，请参阅AWS CLI主题[https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html)。
## 使用 ElastiCache API
如果要向未启用复制的现有 Valkey 或 Redis OSS（已禁用集群模式）集群添加节点，则必须先创建将该现有集群指定为主集群的复制组。有关更多信息，请参阅 [向独立 Valkey 或 Redis OSS（已禁用集群模式）集群添加副本 (API) ElastiCache](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.API)。待该复制组为 *available*（可用）后，您可以继续下面的流程。
**向集群添加节点 (ElastiCache API)**
+ 按照以下参数调用 `IncreaseReplicaCount` API 操作：
+ `ReplicationGroupId` 要将节点添加到的集群的 ID。
+ `NewReplicaCount` `NewReplicaCount` 参数指定应用修改后此集群中应有的节点的数量。要向此集群添加节点，`NewReplicaCount` 必须大于此集群中的当前节点数。如果此值小于当前节点数，请使用 `DecreaseReplicaCount` API 以及要从集群中移除的节点数量。
+ `ApplyImmediately` 指定是立即添加这些节点还是在下一维护时段添加这些节点。
+ `Region`指定要向其添加节点的集群的AWS区域。
以下示例演示向集群添加节点的调用。
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=IncreaseReplicaCount
&ApplyImmediately=true
&NumCacheNodes=4
&ReplicationGroupId=my-replication-group
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
有关更多信息，请参阅 ElastiCache API 主题[https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html)。
## 使用 ElastiCache API
**向集群添加节点 (ElastiCache API)**
+ 按照以下参数调用 `ModifyCacheCluster` API 操作：
+ `CacheClusterId` 要将节点添加到的集群的 ID。
+ `NumCacheNodes` `NumCachNodes` 参数指定应用修改后此集群中应有的节点的数量。要向此集群添加节点，`NumCacheNodes` 必须大于此集群中的当前节点数。如果此值小于当前节点数，则 ElastiCache 需要参数`CacheNodeIdsToRemove`以及要从集群中移除的节点列表（请参阅[在 Memcached 中使用 ElastiCache API](Clusters.DeleteNode.md#Clusters.DeleteNode.API)）。
+ `ApplyImmediately` 指定是立即添加这些节点还是在下一维护时段添加这些节点。
+ `Region`指定要向其添加节点的集群的AWS区域。
以下示例演示向集群添加节点的调用。
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&ApplyImmediately=true
&NumCacheNodes=5
&CacheClusterId=my-cluster
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
有关更多信息，请参阅 ElastiCache API 主题[https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html)。
# 从 ElastiCache 集群中移除节点
你可以使用、或 API 从 Valkey、Memcached 或 Redis OSS 集群中AWS CLI删除节点。AWS 管理控制台 ElastiCache
**注意**
每次更改您的 Memcached 集群中的节点数时，您必须至少重新映射部分键空间，以便它映射到正确的节点。有关对 Memcached 集群进行负载均衡的更多详细信息，请参阅[配置您的 ElastiCache 客户端以实现高效的负载平衡 (Memcached)](BestPractices.LoadBalancing.md)。
## 使用 ElastiCache AWS 管理控制台
**从集群中移除节点（控制台）**
1. 登录AWS 管理控制台并打开 ElastiCache 控制台，网址为[ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 从右上角的列表中，选择要从中移除节点的集群的AWS区域。
1. 在导航窗格中，选择在您要删除节点的集群上运行的引擎。
此时会显示运行所选引擎的集群的列表。
1. 从集群列表中，选择要从中删除节点的集群的名称。
此时会显示集群节点的列表。
1. 选择要删除的节点的节点 ID 左侧的复选框。使用 ElastiCache 控制台时，一次只能删除一个节点，因此选择多个节点表明您无法使用**删除节点**按钮。
此时将显示*删除节点*页面。
1. 要删除节点，请完成**删除节点**页面，然后选择**删除节点**。要保留节点，请选择**取消**。
**重要**
使用 Valkey 或 Redis OSS 时，如果要删除集群中不再符合多可用区标准的节点结果，请确保先清除**多可用区**复选框，然后再删除节点。如果清除**多可用区**复选框，则可以选择启用**自动故障转移**。
**新添加和删除请求对待处理请求的影响**
| 场景 | 待处理的操作 | 新建请求 | 结果 |
| --- | --- | --- | --- |
| 方案 1 | 删除 | 删除 | 新的删除请求（待处理或立即）将替换待处理的删除请求。 例如，如果节点 0001、0003 和 0007 处于等待删除状态，同时发出了删除节点 0002 和 0004 的新请求，则只删除节点 0002 和 0004。节点 0001、0003 和 0007 不会被删除。 |
| 方案 2 | 删除 | Create | 新的创建请求（待处理或立即）将替换待处理的删除请求。 例如，如果节点 0001、0003 和 0007 处于等待删除状态，同时发出了创建节点的新请求，则会创建一个新节点，节点 0001、0003 和 0007 不会被删除。 |
| 方案三 | Create | 删除 | 新的删除请求（待处理或立即）将替换待处理的创建请求。 例如，如果存在创建两个节点的待处理请求，同时发出了删除节点 0003 的新请求，则不会创建新节点，节点 0003 会被删除。 |
| 方案 4 | Create | Create | 新创建请求将添加到待处理创建请求中。 例如，如果存在创建两个节点的待处理请求，同时发出了创建三个节点的新请求，则新请求将添加到待处理请求中，并将创建五个节点。 如果新创建请求设置为 **Apply Immediately - Yes（立即应用 – 是）**，则立即执行所有创建请求。如果新创建请求设置为 **Apply Immediately - No（立即应用 – 否）**，则所有创建请求为待处理。 |
要确定哪些操作处于待处理状态，请选择 **Description（描述）**选项卡，然后查看显示了多少待处理的创建或删除操作。您不能同时拥有待处理的创建操作和待处理的删除操作。
## 使用 wit AWS CLI h ElastiCache
1. 确定要 IDs 移除的节点。有关更多信息，请参阅 [查看 ElastiCache 集群的详细信息](Clusters.ViewDetails.md)。
1. 将 `decrease-replica-count` CLI 操作与要删除的节点列表一起使用，如下例所示。
要使用命令行界面从集群中移除节点，请结合以下参数使用命令 `decrease-replica-count`：
+ `--replication-group-id` 要从其中删除节点的复制组的 ID。
+ `--new-replica-count` `--new-replica-count` 参数指定应用修改后此集群中应有的节点的数量。
+ `--replicas-to-remove`要从 IDs 该集群中移除的节点的列表。
+ `--apply-immediately` 或 `--no-apply-immediately` 指定是立即移除这些节点还是在下一维护时段移除这些节点。
+ `--region`指定要从中移除节点的集群AWS区域。
**注意**
您只能在调用此操作时传递 `--replicas-to-remove` 或者 `--new-replica-count` 参数。
对于 Linux、macOS 或 Unix：
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 2 \
--region us-east-2 \
--apply-immediately
```
对于 Windows：
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 3 ^
--region us-east-2 ^
--apply-immediately
```
此操作将生成类似于以下内容的输出（JSON 格式）：
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test"
},
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005",
"node-test-006"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test-ro.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-004",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-004.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-005",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-005.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-006",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-006.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
或者，您也可以调用 `decrease-replica-count`，而不必传递 `--new-replica-count` 参数，您可以传递 `--replicas-to-remove` 参数，如下所示：
对于 Linux、macOS 或 Unix：
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--replicas-to-remove node-test-003 \
--region us-east-2 \
--apply-immediately
```
对于 Windows：
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--replicas-to-remove node-test-003 ^
--region us-east-2 ^
--apply-immediately
```
有关更多信息，请参阅AWS CLI主题[https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html)。
## 在 Valkey 或 Redis OSS 上使用 ElastiCache API
要使用 ElastiCache API 移除节点，请使用复制组 ID 和要移除的节点列表调用 `DecreaseReplicaCount` API 操作，如下所示：
+ `ReplicationGroupId` 要从其中删除节点的复制组的 ID。
+ `ReplicasToRemove` `ReplicasToRemove` 参数指定应用修改后此集群中应有的节点的数量。
+ `ApplyImmediately` 指定是立即移除这些节点还是在下一维护时段移除这些节点。
+ `Region`指定要从中移除节点的集群AWS区域。
以下示例从集群 my-cluster 中立即删除节点 0004 和 0005。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DecreaseReplicaCount
&ReplicationGroupId=my-replication-group
&ApplyImmediately=true
&ReplicasToRemove=node-test-003
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
有关更多信息，请参阅 ElastiCache API 主题[https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html)。
## 在 Memcached 中使用 ElastiCache API
要使用 ElastiCache API 移除节点，请使用缓存集群 ID 和要移除的节点列表调用 `ModifyCacheCluster` API 操作，如下所示：
+ `CacheClusterId` 要从其中删除节点的集群的 ID。
+ `NumCacheNodes` `NumCacheNodes` 参数指定应用修改后此集群中应有的节点的数量。
+ `CacheNodeIdsToRemove.member.n`要从集群中 IDs 移除的节点列表。
+ `CacheNodeIdsToRemove.member.1=0004`
+ `CacheNodeIdsToRemove.member.1=0005`
+ `ApplyImmediately` 指定是立即移除这些节点还是在下一维护时段移除这些节点。
+ `Region`指定要从中移除节点的集群AWS区域。
以下示例从集群 my-cluster 中立即删除节点 0004 和 0005。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&ApplyImmediately=true
&CacheNodeIdsToRemove.member.1=0004
&CacheNodeIdsToRemove.member.2=0005
&NumCacheNodes=3
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
有关更多信息，请参阅 ElastiCache API 主题[https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html)。
# 取消 ElastiCache 中待处理的添加或删除节点操作
如果您选择不立即应用 ElastiCache 集群更改，则操作将一直保持**等待**状态，直到在您的下一个维护时段执行。您可以取消任何待处理的添加或删除操作。
要通过 AWS CLI 取消待处理的添加或删除节点操作，请使用 `modify-cache-cluster` 命令。将 `num-cache-nodes` 设置为等于集群中当前缓存节点数，然后添加 `--apply-immediately` 标志。这将覆盖待处理的更改。
要取消待处理的节点添加或删除操作，请执行以下步骤：
```
aws elasticache modify-cache-cluster
--cache-cluster-id
--num-cache-nodes
--apply-immediately
```
如果您不清楚是否有任何待处理的节点添加或删除操作，则可以使用 `describe-cache-clusters` 命令确认其状态：
```
aws elasticache describe-cache-clusters
--cache-cluster-id
```
所有待处理的节点都会出现在 `PendingModifiedValues` 输出中。例如：
```
"PendingModifiedValues": {
"NumCacheNodes": 3
},
```
# 删除中的集群 ElastiCache
只要 ElastiCache 集群处于*可用*状态，无论您是否在积极使用它，都需要为此付费。要停止产生费用，请删除此集群。
**警告**
当您删除 ElastiCache 集群时，您的手动快照会被保留。您也可以在删除集群之前创建最终快照。自动缓存快照不会保留。
## 使用AWS 管理控制台
以下过程从您的部署中删除单个集群。要删除多个集群，请对要删除的每个集群重复此过程。在开始删除一个集群的过程之前，您无需等待删除另一个集群完成。
**删除集群**
1. 登录AWS 管理控制台并打开 Amazon ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 在 ElastiCache 引擎仪表板中，选择要删除的集群中正在运行的引擎。
此时会显示运行该引擎的所有集群的列表。
1. 要选择要删除的集群，请从集群列表中选择该集群的名称。
**重要**
您一次只能从 ElastiCache 控制台删除一个集群。选择多个集群会禁用删除操作。
1. 对于**操作**，选择**删除**。
1. 在**删除集群**确认屏幕上，选择**删除**可删除集群，选择**取消**可保留集群。
如果选择了 **Delete**，集群的状态将变为*正在删除*。
只要您的集群不再在集群列表中列出，您就无需为该集群付费。
## 使用AWS CLI删除集 ElastiCache 群
以下代码删除集 ElastiCache 群`my-cluster`。
```
aws elasticache delete-cache-cluster --cache-cluster-id my-cluster
```
`delete-cache-cluster` CLI 操作只会删除一个集群。要删除多个集群，请对要删除的每个缓存集群调用 `delete-cache-cluster`。在删除一个集群之前，您无需等待删除另一个集群的完成。
对于 Linux、macOS 或 Unix：
```
aws elasticache delete-cache-cluster \
--cache-cluster-id my-cluster \
--region us-east-2
```
对于 Windows：
```
aws elasticache delete-cache-cluster ^
--cache-cluster-id my-cluster ^
--region us-east-2
```
有关更多信息，请参阅 f AWS CLI or ElastiCache 主题[https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html)。
## 使用 ElastiCache API
以下代码删除集群 `my-cluster`。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DeleteCacheCluster
&CacheClusterId=my-cluster
&Region us-east-2
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150202T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
`DeleteCacheCluster` API 操作仅删除一个集群。要删除多个集群，请对要删除的每个集群调用 `DeleteCacheCluster`。在删除一个集群之前，您无需等待删除另一个集群的完成。
有关更多信息，请参阅 ElastiCache API 参考主题[https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html)。
# 访问您的 ElastiCache 集群或复制组
您的亚马逊 ElastiCache 实例旨在通过亚马逊 EC2 实例进行访问。
如果您在亚马逊虚拟私有云 (Amazon VPC) 中启动 ElastiCache实 ElastiCache 例，则可以从同一亚马逊 VPC 中的亚马逊 EC2 实例访问您的实例。或者，通过使用 VPC 对等互连，您可以从另一个 Amazon VPC EC2 中的亚马逊访问您的 ElastiCache 实例。
如果您在 EC2 Classic 中启动 ElastiCache 实例，则通过向与该 EC2 实例关联的 Amazon EC2 安全组授予访问您的缓存安全组的权限，允许该实例访问您的集群。默认情况下，仅启动了集群的账户能够访问集群。
**Topics**
+ [授予访问您的集群或复制组的权限](#grant-access)
## 授予访问您的集群或复制组的权限
### 您已将集群启动到 EC2-VPC
如果您在亚马逊虚拟私有云 (Amazon VPC) 中启动 ElastiCache集群，则只能从在同一 Amazon VPC 中运行的亚马逊 EC2 实例连接到您的集群。在此情况下，您需要向集群授予网络进入。
**注意**
如果您正在使用 *Local Zones*，请确保已启用它。有关更多信息，请参阅[启用 Local Zones](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/using-regions-availability-zones.html#opt-in-local-zone)。通过这样做，您的 VPC 将扩展到该 Local Zone，您的 VPC 会将子网视为任何其他可用区中的任何子网，并且相关网关、路由表和其他安全组注意事项将自动调整。
**授予从 Amazon VPC 安全组到集群的网络入口**
1. 登录AWS 管理控制台并打开 Amazon EC2 控制台，网址为[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中的 **Network & Security** 下，选择 **Security Groups**。
1. 从安全组列表中，为 Amazon VPC 选择安全组。除非您创建了供 ElastiCache 使用的安全组，否则该安全组将被命名为 de *fault*。
1. 选择 **Inbound** 选项卡，然后执行以下操作：
1. 选择 **Edit**（编辑）。
1. 选择**添加规则**。
1. 在 **Type** 列中，选择 **Custom TCP rule**。
1. 在 **Port range** 框中，为您的集群节点键入端口号。此端口号必须与启动集群时指定的端口号相同。Memcached 的默认端口是 **11211**。Valkey 和 Redis OSS 的默认端口是 **6379**。
1. 在**源**框中，选择**任何具有端口范围 (0.0.0.0/0) 的任意位置**，这样您在 Amazon VPC 中启动的任何 Amazon EC2 实例都可以连接到您的节点。 ElastiCache
**重要**
将 ElastiCache 集群开放到 0.0.0.0/0 不会将集群暴露在互联网上，因为它没有公有 IP 地址，因此无法从 VPC 外部进行访问。但是，默认安全组可以应用于客户账户中的其他 Amazon EC2 实例，并且这些实例可能具有公有 IP 地址。如果这些实例碰巧在默认端口上运行某些内容，则该服务可能会意外暴露。因此，我们建议创建将由 ElastiCache 独占使用的 VPC 安全组。有关更多信息，请参阅[自定义安全组](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#creating-your-own-security-groups)。
1. 选择**保存**。
当您在您的 Amazon EC2 VPC 中启动亚马逊实例时，该实例将能够连接到您的 ElastiCache 集群。
### 从外部访问 ElastiCache 资源AWS
Amazon ElastiCache 是一项提供基于云的内存键值存储的AWS服务。该服务旨在仅从内部访问AWS。但是，如果 ElastiCache 集群托管在 VPC 内，则可以使用网络地址转换 (NAT) 实例提供外部访问。
#### 要求
要从外部访问您的 ElastiCache 资源，必须满足以下要求AWS：
+ 集群必须驻留在 VPC 中，并且可以通过网络地址转换 (NAT) 实例访问。此要求不存在例外情况。
+ NAT 实例必须在与集群相同的 VPC 中启动。
+ NAT 实例必须在与集群分开的公有子网中启动。
+ 弹性 IP 地址 (EIP) 必须与 NAT 实例关联。iptables 的端口转发功能用于将 NAT 实例上的端口转发到 VPC 中的缓存节点端口。
#### 注意事项
从外部 ElastiCache 访问您的 ElastiCache 资源时，必须牢记以下注意事项。
+ 客户端连接到 NAT 实例的 EIP 和缓存端口。NAT 实例上的端口转发功能会将流量转发到相应的集群节点。
+ 如果添加或替换集群节点，则需要更新 iptables 规则以反映此更改。
#### 限制
此方法应仅应用于测试和开发用途。由于以下限制，不建议将其用于生产用途：
+ NAT 实例用作客户端与多个集群之间的代理。添加代理会影响集群的性能。这种影响会随着您通过 NAT 实例访问的集群数量增加而增大。
+ 从客户端到 NAT 实例的流量未加密。因此，您应当避免通过 NAT 实例发送敏感数据。
+ NAT 实例增加了维护另一实例的开销。
+ NAT 实例会成为单点故障。有关如何在 VPC 上设置高可用性 NAT 的信息，请参阅 [Amazon VPC NAT 实例的高可用性：示例](https://aws.amazon.com/articles/2781451301784570)。
#### 如何从外部访问 ElastiCache 资源AWS
以下过程演示如何使用 NAT 实例连接到您的 ElastiCache 资源。
这些步骤假定以下各项：
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379`
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379`
接下来，您需要相反方向的 NAT：
`iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 10.0.0.55`
您还需要启用 IP 转发，该功能默认情况下处于禁用状态：
`sudo sed -i 's/net.ipv4.ip_forward=0/net.ipv4.ip_forward=1/g' /etc/sysctl.conf sudo sysctl --system`
+ 您可以使用以下项访问 Memcached 集群：
+ IP 地址 – *10.0.1.230*
+ 默认 Memcached 端口 – *11211*
+ 安全组：*\$110\$1.0\$1.0\$1.55\$1*
+ 您可以使用以下项访问 Valkey 或 Redis OSS 集群：
+ IP 地址 – *10.0.1.230*
+ 默认端口 – *6379*
+ 安全组 – *sg-bd56b7da*
+ AWS实例 IP 地址 — *198* .99.100.27
+ 您的可信客户端使用 IP 地址 *198.51.100.27*。
+ 您的 NAT 实例具有弹性 IP 地址 *203.0.113.73*。
+ 您的 NAT 实例具有安全组 *sg-ce56b7a9*。
**使用 NAT 实例连接到您的 ElastiCache 资源**
1. 在与集群相同的 VPC 中创建 NAT 实例，但位于公有子网上。
默认情况下，VPC 向导将启动 *cache.m1.small* 节点类型。您应该根据需求选择节点大小。您必须使用 EC2 NAT AMI 才能 ElastiCache 从外部进行访问AWS。
有关创建 NAT 实例的信息，请参阅AWS VPC 用户指南中的 [NAT 实例](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)。
1. 为集群和 NAT 实例创建安全组规则。
NAT 实例安全组和集群实例应具有以下规则：
+ 两个入站规则
+ 对于 Memcached，第一个规则是允许从可信客户端到每个缓存端口的 TCP 连接，这些缓存端口是从 NAT 实例（11211 - 11213）转发的。
+ 对于 Valkey 和 Redis OSS，第一个规则是允许从可信客户端到每个缓存端口的 TCP 连接，这些缓存端口是从 NAT 实例（6379 - 6381）转发的。
+ 第二个规则用于允许 SSH 访问可信客户端。
**NAT 实例安全组 – 入站规则（Memcached）**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/accessing-elasticache.html)
**NAT 实例安全组 – 入站规则（Valkey 或 Redis OSS）**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Memcached：一个出站规则，允许与缓存端口（11211）建立 TCP 连接。
**NAT 实例安全组 – 出站规则**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Valkey 或 Redis OSS：一个出站规则，允许与缓存端口（6379）建立 TCP 连接。
**NAT 实例安全组 – 出站规则**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Memcached：集群安全组的入站规则，允许从 NAT 实例到缓存端口（11211）的 TCP 连接。
**集群实例安全组 – 入站规则**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Valkey 或 Redis OSS：集群安全组的入站规则，允许从 NAT 实例到缓存端口（6379）的 TCP 连接。
**集群实例安全组 – 入站规则**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/accessing-elasticache.html)
1. 验证规则。
+ 确认可信客户端可以通过 SSH 连接到 NAT 实例。
+ 确认可信客户端能够从 NAT 实例连接到集群。
1. **Memcached**
将 iptables 规则添加到 NAT 实例。
必须为集群中的每个节点将 iptables 规则添加到 NAT 表，以便将缓存端口从 NAT 实例转发到集群节点。示例如下所示：
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
```
集群中每个节点的端口号必须唯一。例如，如果处理使用端口 11211 - 11213 的三个节点的 Memcached 集群，则规则将如下所示：
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11212 -j DNAT --to 10.0.1.231:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11213 -j DNAT --to 10.0.1.232:11211
```
确认可信客户端能够连接到集群。
可信客户端应连接到与 NAT 实例关联的 EIP 以及对应于相应集群节点的集群端口。例如，PHP 的连接字符串如下所示：
```
$memcached->connect( '203.0.113.73', 11211 );
$memcached->connect( '203.0.113.73', 11212 );
$memcached->connect( '203.0.113.73', 11213 );
```
也可以使用 telnet 客户端来验证连接。例如：
```
telnet 203.0.113.73 11211
telnet 203.0.113.73 11212
telnet 203.0.113.73 11213
```
**Valkey 或 Redis OSS**
将 iptables 规则添加到 NAT 实例。
必须为集群中的每个节点将 iptables 规则添加到 NAT 表，以便将缓存端口从 NAT 实例转发到集群节点。示例如下所示：
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
```
集群中每个节点的端口号必须唯一。例如，如果是三个节点的 Redis OSS 集群，使用端口 6379 - 6381，则规则将如下所示：
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379
```
确认可信客户端能够连接到集群。
可信客户端应连接到与 NAT 实例关联的 EIP 以及对应于相应集群节点的集群端口。例如，PHP 的连接字符串如下所示：
```
redis->connect( '203.0.113.73', 6379 );
redis->connect( '203.0.113.73', 6380 );
redis->connect( '203.0.113.73', 6381 );
```
也可以使用 telnet 客户端来验证连接。例如：
```
telnet 203.0.113.73 6379
telnet 203.0.113.73 6380
telnet 203.0.113.73 6381
```
1. 保存 iptables 配置。
在您测试和验证规则之后保存规则。如果您使用基于 Redhat 的 Linux 分发（例如 Amazon Linux），请运行以下命令：
```
service iptables save
```
#### 相关主题
下列主题可能会有用处。
+ [用于访问 Amazon VPC 中的 ElastiCache 缓存的访问模式](elasticache-vpc-accessing.md)
+ [从运行于客户数据中心中的应用程序访问 ElastiCache 缓存](elasticache-vpc-accessing.md#elasticache-vpc-accessing-data-center)
+ [NAT 实例](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
+ [配置 ElastiCache 客户端](ClientConfig.md)
+ [Amazon VPC NAT 实例的高可用性：示例](https://aws.amazon.com/articles/2781451301784570)
# 查找 ElastiCache 中的缓存连接端点
您的应用程序使用端点连接到 ElastiCache 集群。端点是节点或集群的唯一的地址。
您也可以通过 AWS PrivateLink 创建接口 VPC 端点，在 VPC 和 ElastiCache API 端点之间建立私有连接。有关更多信息，请参阅 [ElastiCache API 和接口 VPC 终端节点 (AWS PrivateLink)](elasticache-privatelink.md)。
**在 Valkey 或 Redis OSS 上使用哪些端点**
+ 对于**独立节点**，使用该节点的端点进行读取和写入操作。
+ 对于 **Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）集群**，使用*主端点*执行所有写入操作。使用*读取器端点* 将在所有只读副本之间均匀地分配指向端点的传入连接。使用单独的*节点端点* 进行读取操作（在 API/CLI 中，它们被称作读取端点）。
+ 对于 **Valkey 或 Redis OSS（已启用集群模式）集群**，使用集群的*配置端点*执行所有支持已启用集群模式命令的操作。您必须使用支持 Valkey 集群或 Redis OSS 集群（运行 Redis OSS 3.2 及更高版本）的客户端。您仍可以从独立的节点端点进行读取（在 API/CLI 中，它们被称作读取端点）。
以下部分将引导您发现正在运行的引擎所需的端点。
**哪些端点可用于 Memcached。**
对于**适用于 Memcached 的 ElastiCache 无服务器缓存**，只需从控制台获取集群端点 DNS 和端口。
从 AWS CLI 中，使用 `describe-serverless-caches` 命令获取端点信息。
Linux
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Windows
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
上述操作的输出类似于以下内容（JSON 格式）：
```
{
"ServerlessCaches": [
{
"ServerlessCacheName": "serverless-memcached",
"Description": "test",
"CreateTime": 1697659642.136,
"Status": "available",
"Engine": "memcached",
"MajorEngineVersion": "1.6",
"FullEngineVersion": "21",
"SecurityGroupIds": [
"sg-083eda453e1e51310"
],
"Endpoint": {
"Address": "serverless-memcached-01.amazonaws.com",
"Port":11211
},
"ARN": "",
"SubnetIds": [
"subnet-0cf759df15bd4dc65",
"subnet-09e1307e8f1560d17"
],
"SnapshotRetentionLimit": 0,
"DailySnapshotTime": "03:00"
}
]
}
```
**对基于 Memcached 集群的实例**，如果您使用自动发现，则可以使用集群的*配置端点*来配置您的 Memcached 客户端。这意味着您必须使用支持 Automatic Discovery 的客户端。
如果您不使用 Automatic Discovery，则必须对客户端进行配置，以便针对读取和写入使用不同的节点端点。此外，在添加或删除节点时，您还必须跟踪它们的情况。
## 查找 Valkey 或 Redis OSS（已禁用集群模式）集群端点（控制台）
如果 Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）集群只有一个节点，则使用该节点的端点进行读取和写入操作。如果 Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）集群具有多个节点，则有三种类型的端点，即*主端点*、*读取器端点*和*节点端点*。
主端点是一个 DNS 名称，始终解析为集群中的主节点。主端点不受集群更改的影响，如将只读副本提升为主角色。对于写入活动，我们建议您的应用程序连接到主端点。
读取器端点将在 ElastiCache for Redis OSS 集群中的所有只读副本之间均匀地分配指向端点的传入连接。应用程序何时创建连接或应用程序如何（重复）使用连接等附加因素将决定流量分配。读取器端点会在添加或删除副本时实时跟踪集群更改。您可以将 ElastiCache for Redis OSS 集群的多个只读副本置于不同的 AWS 可用区（AZ）中以确保读取器端点的高可用性。
**注意**
读取器端点不是负载均衡器。它是一个 DNS 记录，将以循环方式解析为副本节点之一的 IP 地址。
对于读取活动，应用程序还可以连接到集群中的任何节点。与主端点不同，节点端点会解析为特定端点。如果您在您的集群中进行更改（例如添加或删除副本），则必须在您的应用程序中更新节点端点。
**查找 Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）集群端点**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 在导航窗格中，选择 **Valkey 集群**或 **Redis OSS 集群**。
集群屏幕将显示 Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）和 Valkey 或 Redis OSS（已启用集群模式）集群的列表。
1. 要查找集群的主端点和/或读取器端点，请选中集群的名称（而不是其左侧的按钮）。
![\[图片：Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）集群的主端点\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)
*Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）集群的主端点和读取器端点*
如果该集群只有一个节点，则没有主端点，您可以继续下一步。
1. 如果 Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）集群有副本节点，您可以通过选择该集群的名称，然后选择**节点**选项卡，找到该集群的副本节点端点。
此时会显示节点屏幕，其中列出了集群中的每个节点（主节点和副本节点）及其端点。
![\[图片：Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）集群的节点端点\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)
*Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）集群的节点端点*
1. 将端点复制到剪贴板：
1. 逐一找到要复制的端点。
1. 直接选择端点前面的复制图标。
端点现已复制到剪贴板。有关使用端点连接到节点的信息，请参阅 [连接到 Memcached 节点](nodes-connecting.md#nodes-connecting.mem)。
Valkey 或者 Valkey 或 Redis OSS（已禁用集群模式）主端点类似以下内容。根据是否已启用传输中加密而有所不同。
**未启用传输中加密**
```
clusterName.xxxxxx.nodeId.regionAndAz.cache.amazonaws.com:port
redis-01.7abc2d.0001.usw2.cache.amazonaws.com:6379
```
**已启用传输中加密**
```
master.clusterName.xxxxxx.regionAndAz.cache.amazonaws.com:port
master.ncit.ameaqx.use1.cache.amazonaws.com:6379
```
## 查找 Valkey 或 Redis OSS（已启用集群模式）集群的端点（控制台）
Valkey 或 Redis OSS（已启用集群模式）集群有一个单配置端点。通过连接到配置端点，您的应用程序可以查找集群中每个分片的主端点和读取端点。
**查找 Valkey 或 Redis OSS（已启用集群模式）集群的端点**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 在导航窗格中，选择 **Valkey 集群**或 **Redis OSS 集群**。
集群屏幕随即出现，其中显示集群的列表。选择您想要连接到的集群。
1. 要查找集群的配置端点，请选择集群的名称（不是单选按钮）。
1. **Cluster details**（集群详细信息）下将显示 **Configuration endpoint**（配置端点）。要复制它，请选择位于端点左侧的 *copy*（复制）图标。
## 查找集群的端点（控制台）（Memcached）
所有 Memcached 端点都是读写端点。要连接到 Memcached 集群中的节点，您的应用程序可以使用每个节点的端点或将集群的配置端点与 Automatic Discovery 结合使用。要使用 Automatic Discovery，您必须使用支持 Automatic Discovery 的客户端。
在使用 Automatic Discovery 时，您的客户端应用程序将使用配置端点连接到 Memcached 集群。当您通过添加或移除节点来扩展集群，应用程序将自动“获知”集群中的所有节点并能够连接到其中任一节点。如果没有 Automatic Discovery，应用程序将必须执行此操作，否则，您在每次添加或移除节点时，必须手动更新应用程序中的端点。
要复制端点，请直接选择端点地址前面的复制图标。有关使用端点连接到节点的信息，请参阅 [连接到 Memcached 节点](nodes-connecting.md#nodes-connecting.mem)。
配置端点和节点端点看上非常相似。不同之处以**粗体** 形式突出显示。
```
myclustername.xxxxxx.cfg.usw2.cache.amazonaws.com:port # configuration endpoint contains "cfg"
myclustername.xxxxxx.0001.usw2.cache.amazonaws.com:port # node endpoint for node 0001
```
**重要**
如果您选择为 Memcached 配置端点创建别名记录，以使自动发现客户端可以识别别名记录作为配置端点，则必须在别名记录中包含 `.cfg.`。
## 查找端点（AWS CLI）
对于 Memcached，您可以使用 AWS CLI for Amazon ElastiCache 来搜索节点和集群的端点。
对于 Redis OSS，您可以使用 AWS CLI for Amazon ElastiCache 来搜索节点、集群和复制组的端点。
**Topics**
+ [查找节点和集群的端点（AWS CLI）](#Endpoints.Find.CLI.Nodes)
+ [查找 Valkey 或 Redis OSS 复制组的端点（AWS CLI）](#Endpoints.Find.CLI.ReplGroups)
### 查找节点和集群的端点（AWS CLI）
您可以使用 AWS CLI，通过 `describe-cache-clusters` 命令查找集群及其节点的端点。对于 Valkey 或 Redis OSS 集群，此命令将返回集群端点。对于 Memcached 集群，此命令将返回配置端点。如果包含可选参数 `--show-cache-node-info`，则此命令还将返回集群中的单个节点的端点。
**Example**
以下命令会检索 Memcached 集群 *mycluster* 的配置端点（`ConfigurationEndpoint`）和单个节点端点（`Endpoint`）。
对于 Linux、macOS 或 Unix：
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
对于 Windows：
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
上面的操作输出类似以下的内容（JSON 格式）。
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0003",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-22T21:30:29.967Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 3,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "mon:09:00-mon:10:00",
"CacheNodeType": "cache.m4.large",
"DataTiering": "disabled"
}
]
}
```
如果您选择为 Memcached 配置端点创建别名记录，以使自动发现客户端可以识别别名记录作为配置端点，则必须在别名记录中包含 `.cfg.`。例如，php.ini 文件中的 `mycluster.cfg.local` 参数的 `session.save_path`。
**Example**
对于 Valkey 和 Redis OSS，以下命令会检索单节点集群 *mycluster* 的集群信息。
参数 `--cache-cluster-id` 可与 Redis 复制组中的单节点 Valkey 或 Redis OSS（已禁用集群模式）集群 ID 或特定节点 ID 配合使用。复制组的 `--cache-cluster-id` 是一个四位值，例如 `0001`。如果 `--cache-cluster-id` 是复制组中集群（节点）的 ID，输出中会包含 `replication-group-id`。
对于 Linux、macOS 或 Unix：
```
aws elasticache describe-cache-clusters \
--cache-cluster-id redis-cluster \
--show-cache-node-info
```
对于 Windows：
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id redis-cluster ^
--show-cache-node-info
```
上面的操作输出类似以下的内容（JSON 格式）。
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"SecurityGroupId": "sg-77186e0d",
"Status": "active"
}
],
"CacheNodes": [
{
"CustomerAvailabilityZone": "us-east-1b",
"CacheNodeCreateTime": "2018-04-25T18:19:28.241Z",
"CacheNodeStatus": "available",
"CacheNodeId": "0001",
"Endpoint": {
"Address": "redis-cluster.amazonaws.com",
"Port": 6379
},
"ParameterGroupStatus": "in-sync"
}
],
"AtRestEncryptionEnabled": false,
"CacheClusterId": "redis-cluster",
"TransitEncryptionEnabled": false,
"CacheParameterGroup": {
"ParameterApplyStatus": "in-sync",
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.redis3.2"
},
"NumCacheNodes": 1,
"PreferredAvailabilityZone": "us-east-1b",
"AutoMinorVersionUpgrade": true,
"Engine": "redis",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "tue:08:30-tue:09:30",
"CacheSecurityGroups": [],
"CacheSubnetGroupName": "default",
"CacheNodeType": "cache.t2.small",
"DataTiering": "disabled"
"EngineVersion": "3.2.10",
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheClusterCreateTime": "2018-04-25T18:19:28.241Z"
}
]
}
```
有关更多信息，请参阅主题 [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html)。
### 查找 Valkey 或 Redis OSS 复制组的端点（AWS CLI）
您可以使用 AWS CLI，通过 `describe-replication-groups` 命令查找复制组及其集群的端点。此命令将返回复制组的主端点、复制组中所有集群（节点）及其端点的列表以及读取器端点。
以下操作检索复制组 `myreplgroup` 的主端点和读取器端点。将主端点用于所有写入操作。
```
aws elasticache describe-replication-groups \
--replication-group-id myreplgroup
```
对于 Windows：
```
aws elasticache describe-replication-groups ^
--replication-group-id myreplgroup
```
该操作输出类似以下的内容（JSON 格式）。
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "test",
"NodeGroups": [
{
"Status": "available",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-001.amazonaws.com"
},
"CacheClusterId": "myreplgroup-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-002.amazonaws.com"
},
"CacheClusterId": "myreplgroup-002"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-003.amazonaws.com"
},
"CacheClusterId": "myreplgroup-003"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "myreplgroup.amazonaws.com"
},
"ReaderEndpoint": {
"Port": 6379,
"Address": "myreplgroup-ro.amazonaws.com"
}
}
],
"ReplicationGroupId": "myreplgroup",
"AutomaticFailover": "enabled",
"SnapshottingClusterId": "myreplgroup-002",
"MemberClusters": [
"myreplgroup-001",
"myreplgroup-002",
"myreplgroup-003"
],
"PendingModifiedValues": {}
}
]
}
```
有关更多信息，请参阅 *AWS CLI 命令参考*中的 [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html)。
## 查找端点（ElastiCache API）
对于 Memcached，您可以使用 Amazon ElastiCache API 来搜索节点和集群的端点。
对于 Redis OSS，您可以使用 Amazon ElastiCache API 来搜索节点、集群和复制组的端点。
**Topics**
+ [查找节点和集群的端点（ElastiCache API）](#Endpoints.Find.API.Nodes)
+ [查找 Valkey 或 Redis OSS 复制组的端点（ElastiCache API）](#Endpoints.Find.API.ReplGroups)
### 查找节点和集群的端点（ElastiCache API）
您可以使用 ElastiCache API，通过 `DescribeCacheClusters` 操作查找集群及其节点的端点。对于 Valkey 或 Redis OSS 集群，此命令将返回集群端点。对于 Memcached 集群，此命令将返回配置端点。如果包含可选参数 `ShowCacheNodeInfo`，则此操作还将返回集群中的各个节点的端点。
**Example**
对于 Memcached，以下命令会检索 Memcached 集群 *mycluster* 的配置端点（`ConfigurationEndpoint`）和单个节点端点（`Endpoint`）。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=mycluster
&ShowCacheNodeInfo=true
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
如果您选择为 Memcached 配置端点创建别名记录，以使自动发现客户端可以识别别名记录作为配置端点，则必须在别名记录中包含 `.cfg.`。例如，php.ini 文件中的 `mycluster.cfg.local` 参数的 `session.save_path`。
### 查找 Valkey 或 Redis OSS 复制组的端点（ElastiCache API）
您可以使用 ElastiCache API，以通过 `DescribeReplicationGroups` 操作查找复制组及其集群的端点。此操作将返回复制组的主端点、复制组中所有集群及其端点的列表以及读取器端点。
以下操作检索复制组 `myreplgroup` 的主端点（PrimaryEndpoint）、读取器端点（ReaderEndpoint）和各个节点端点（ReadEndpoint）。将主端点用于所有写入操作。
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=myreplgroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
有关更多信息，请参阅 [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html)。
# 在 ElastiCache 中使用分片
分片（API/CLI：节点组）是 1 到 6 个 ElastiCache for Valkey 或 ElastiCache for Redis OSS 节点的集合。Valkey 或 Redis OSS（已禁用集群模式）集群永远不会有多个分片。使用分片，您可以将大型数据库分成更小、更快、更易于管理的部分，这些部分称为数据分片。这可以通过在多个独立部分之间分配操作来提高数据库效率。使用分片可以带来许多好处，包括提高性能、可扩展性和成本效益。
您可以创建具有更多分片和更少副本的集群，每个集群最多可包含 90 个节点。此集群配置的范围可以从 90 个分片和 0 个副本到 15 个分片和 5 个副本，这是允许的最大副本数。集群的数据分配到该集群的各个分片上。如果分片包含多个节点，则该分片实现了一个节点作为读取/写入主节点且其他节点为只读副本节点的复制。
如果引擎为 Valkey 7.2 及更高版本或 Redis OSS 5.0.6 至 7.1，则您可以将每个集群的节点或分片上限增至最多 500 个。例如，您可以选择配置一个 500 节点的集群，范围介于 83 个分片（一个主分片和 5 个副本分片）和 500 个分片（一个主分片，无副本分片）之间。确保可提供足够的 IP 地址来满足增长需求。常见的陷阱包括子网组中的子网 CIDR 范围太小，或者子网被其他集群共享和大量使用。有关更多信息，请参阅 [创建子网组](SubnetGroups.Creating.md)。
对于低于 5.0.6 的版本，每个集群的限制为 250。
若要请求提高限制，请参阅 [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) 并选择限制类型 **Nodes per cluster per instance type（每个实例类型的每个集群的节点数）**。
使用 ElastiCache 控制台创建 Valkey 或 Redis OSS（已启用集群模式）集群时，您可以指定集群中的分片数和分片中的节点数。有关更多信息，请参阅 [创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster)。使用 ElastiCache API 或 AWS CLI 创建集群（在 API/CLI 中称作*复制组*）时，您可以独立地配置分区（API/CLI：节点组）中的节点数。有关更多信息，请参阅下列内容：
+ API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI：[create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
分片中每个节点的计算、存储和内存规格均相同。通过 ElastiCache API 可以控制分区范围的属性，如节点数、安全设置和系统维护时段。
![\[图片：Valkey 或 Redis OSS 分片配置。\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-CSN-RedisShards.png)
*Valkey 或 Redis OSS 分片配置*
有关更多信息，请参阅[Valkey 或 Redis OSS（已启用集群模式）的离线重新分片](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-offline)和[Valkey 或 Redis OSS（已启用集群模式）的离线重新分片](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online)。
## 查找分区的 ID
您可以使用 AWS 管理控制台、AWS CLI 或 ElastiCache API 查找分区的 ID。
### 使用 AWS 管理控制台
**Topics**
+ [对于 Valkey 或 Redis OSS（已禁用集群模式）](#shard-find-id-con-classic)
+ [对于 Valkey 或 Redis OSS（已启用集群模式）](#shard-find-id-con-cluster)
#### 对于 Valkey 或 Redis OSS（已禁用集群模式）
Valkey 或 Redis OSS（已禁用集群模式）复制组分片 ID 始终为 `0001`。
#### 对于 Valkey 或 Redis OSS（已启用集群模式）
以下过程使用 AWS 管理控制台 查找 Valkey 或 Redis OSS（已启用集群模式）的复制组的分片 ID。
**在 Valkey 或 Redis OSS（已启用集群模式）复制组中查找分片 ID**
1. 登录 AWS 管理控制台 并打开 ElastiCache 控制台（[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)）。
1. 在导航窗格上，选择 **Valkey** 或 **Redis OSS**，然后选择要为其查找分片 ID 的 Valkey 或 Redis OSS（已启用集群模式）复制组的名称。
1. 在 **Shard Name（分区名称）**列中，分区 ID 是分区名称的最后四位数字。
### 使用 AWS CLI
要为 Valkey 或 Redis OSS（已禁用集群模式）或 Valkey 或 Redis OSS（已启用集群模式）复制组查找分片（节点组）ID，请使用以下可选参数执行 AWS CLI 操作 `describe-replication-groups`。
+ **– `--replication-group-id`** 用来将输出限制为指定复制组的详细信息的可选参数。如果忽略此参数，将返回最多 100 个复制组的详细信息。
**Example**
此命令将返回 `sample-repl-group` 的详细信息。
对于 Linux、macOS 或 Unix：
```
aws elasticache describe-replication-groups \
--replication-group-id sample-repl-group
```
对于 Windows：
```
aws elasticache describe-replication-groups ^
--replication-group-id sample-repl-group
```
该命令的输出类似于此处所示。分片（节点组）ID 在此处*突出显示*，以便更容易找到它们。
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "sample-repl-group.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "sample-repl-group",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"sample-repl-group-0001-001",
"sample-repl-group-0001-002",
"sample-repl-group-0002-001",
"sample-repl-group-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
"PendingModifiedValues": {}
}
]
}
```
### 使用 ElastiCache API
要为 Valkey 或 Redis OSS（已禁用集群模式）或 Valkey 或 Redis OSS（已启用集群模式）复制组查找分片（节点组）ID，请使用以下可选参数执行 AWS CLI 操作 `describe-replication-groups`。
+ **– `ReplicationGroupId`** 用来将输出限制为指定复制组的详细信息的可选参数。如果忽略此参数，将返回最多 *xxx* 个复制组的详细信息。
**Example**
此命令将返回 `sample-repl-group` 的详细信息。
对于 Linux、macOS 或 Unix：
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroup
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
# 比较 Valkey、Memcached 和 Redis OSS 基于节点的集群
亚马逊 ElastiCache 支持 Valkey、Memcached 和 Redis OSS 缓存引擎。每种引擎都有自己的优点。使用本主题中的信息有助于您选择出最能满足您的要求的引擎和版本。
**重要**
创建基于节点的缓存群集或复制组后，您可以升级到较新的引擎版本，但不能降级到较旧的引擎版本。如果您要使用较旧的引擎版本，必须删除现有的基于节点的缓存群集或复制组，并使用较旧的引擎版本重新创建。
从表面上看，这两个引擎十分类似。其中的每个引擎都是一个内存中键/值存储。不过，这两者实际上有很大差异。
**如果您存在以下情况，请选择 Memcached：**
+ 您需要使模型尽可能简单。
+ 您需要运行具有多个核心或线程的大型节点。
+ 您需要具备缩放能力，随着系统需求的增加和减少来添加和移除节点。
+ 您需要缓存对象。
**ElastiCache 如果符合以下条件，请选择 Valkey 或 Redis OSS：**
+ **ElastiCache 适用于 Valkey 的 7.2 版或 Redis OSS 的 7.0 版（增强版）**
您想使用[函数](https://valkey.io/topics/functions-intro/)、[分片发布/订阅](https://valkey.io/topics/pubsub/)或 [ACL 改进](https://valkey.io/topics/acl/)。有关更多信息，请参阅 [Redis OSS 版本 7.0（加强版）](engine-versions.md#redis-version-7.0)。
+ **ElastiCache 适用于 Redis OSS 的 6.2 版（增强版）**
您希望能够使用 r6gd 节点类型在内存和 SSD 之间进行数据分层。有关更多信息，请参阅[数据分层](data-tiering.md)。
+ **ElastiCache 适用于 Redis OSS 的 6.0 版（增强版）**
您希望使用基于角色的访问控制对用户进行身份验证。
有关更多信息，请参阅 [Redis OSS 版本 6.0（加强版）](engine-versions.md#redis-version-6.0)。
+ **ElastiCache 适用于 Redis OSS 的 5.0.0 版（增强版）**
您需要使用 [Redis OSS 流](https://redis.io/topics/streams-intro)，它是一个日志数据结构，允许生成者实时附加新项，并允许使用者以阻塞或非阻塞方式使用消息。
有关更多信息，请参阅 [Redis OSS 版本 5.0.0（加强版）](engine-versions.md#redis-version-5-0)。
+ **ElastiCache 适用于 Redis OSS 的 4.0.10（增强版）**
支持加密以及从您的 Valkey 或 Redis OSS（已启用集群模式）集群动态添加或移除分片。
有关更多信息，请参阅 [Redis OSS 版本 4.0.10（加强版）](engine-versions.md#redis-version-4-0-10)。
以下版本已弃用、已达到使用寿命或即将达到使用寿命。
+ **ElastiCache 适用于 Redis OSS 的 3.2.10 版（增强版）**
支持从您的 Valkey 或 Redis OSS（已启用集群模式）集群动态添加或移除分片的功能。
**重要**
目前，适用于 Redis OSS 的 ElastiCache 3.2.10 不支持加密。
有关更多信息，请参阅下列内容：
+ [Redis OSS 3.2.10 版（加强版）](engine-versions.md#redis-version-3-2-10)
+ Redis OSS 的在线重新分片最佳实践，有关更多信息，请参阅：
+ [最佳实践：在线重新分片](best-practices-online-resharding.md)
+ [Valkey 或 Redis OSS（已启用集群模式）的在线重新分片和分片重新平衡](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online)
+ 有关扩展 Redis OSS 集群的更多信息，请参阅[扩展](Scaling.md)。
+ **ElastiCache 适用于 Redis OSS 的 3.2.6 版（增强版）**
如果您需要较旧 Redis OSS 版本的功能外加以下功能，请选择 3.2.6：
+ 传输中加密。有关更多信息，请参阅 [Amazon f ElastiCache or Redis OSS 传输中](in-transit-encryption.md)加密。
+ 静态加密。有关更多信息，请参阅 [Amazon f ElastiCache or Redis OSS 静态加密](at-rest-encryption.md)。
+ **ElastiCache （已启用集群模式）适用于 Redis OSS 的 3.2.4 版**
如果需要 2.8.x 的功能外加以下功能，请选择 3.2.4（集群模式）：
+ 您需要在 2 到 500 个节点组（仅限集群模式）之间对数据分区。
+ 您需要地理空间索引（集群模式或非集群模式）。
+ 您不需要支持多个数据库。
+ **ElastiCache （非集群模式）适用于 Redis OSS 的 2.8.x 和 3.2.4（增强版）**
如果您存在以下情况，请选择 2.8.x 或 3.2.4（非集群模式）：
+ 您需要复杂数据类型，如字符串、哈希、列表、集、排序集和位图。
+ 您需要对内存数据集进行排序或排名。
+ 您需要持久保留密钥库。
+ 您需要为读取操作密集型应用程序将主集群中的数据复制到一个或多个只读副本。
+ 您需要在主节点出现故障的情况下执行自动故障转移。
+ 您需要发布和订阅 (pub/sub) 功能 – 向客户端通知服务器上发生的事件。
+ 您需要为基于节点的集群以及无服务器缓存提供备份和还原功能。
+ 您需要支持多个数据库。
**Memcached、Valkey 或 Redis OSS（已禁用集群模式）和 Valkey 或 Redis OSS（已启用集群模式）的比较摘要**
| | Memcached | Valkey 或 Redis OSS（已禁用集群模式） | Valkey 或 Redis OSS（已启用集群模式） |
| --- |--- |--- |--- |
| 引擎版本\$1 | 1.4.5 及更高版本 | 4.0.10 及后续版本 | 4.0.10 及后续版本 |
| 数据类型 | 简便 | 2.8.x - 复杂 \$1 | 3.2.x 及更高版本 - 复杂 |
| 复杂 |
| 数据分区 | 是 | 否 | 是 |
| 集群是可修改的 | 支持 | 是 | 3.2.10 及更高版本 - 有限 |
| 在线重新分片 | 否 | 否 | 3.2.10 和后续版本 |
| 加密 | 在途 1.6.12 及更高版本 | 4.0.10 及后续版本 | 4.0.10 及后续版本 |
| 数据分层 | 否 | 6.2 及更高版本 | 6.2 及更高版本 |
| 合规性认证 |
| --- |
| 合规性认证 FedRAMP HIPAA PCI DSS | 是 - 1.6.12 及更高版本 是 - 1.6.12 及更高版本 是 | 4.0.10 及后续版本 4.0.10 及后续版本 4.0.10 及后续版本 | 4.0.10 及后续版本 4.0.10 及后续版本 4.0.10 及后续版本 |
| 多线程 | 是 | 否 | 否 |
| 节点类型升级 | 否 | 是 | 是 |
| 引擎升级 | 支持 | 是 | 是 |
| 高可用性 (复制) | 否 | 是 | 是 |
| 自动失效转移 | 否 | 可选 | 必需 |
| 发布/订阅功能 | 否 | 是 | 是 |
| 排序集 | 否 | 是 | 是 |
| 备份和还原 | 仅适用于无服务器缓存，不适用于基于节点的集群 | 支持 | 是 |
| 地理空间索引 | 否 | 4.0.10 及后续版本 | 是 |
| 备注： |
| 字符串、对象（如数据库） |
| \$1 字符串、集、排序集、列表、哈希、位图、hyperloglog |
| 字符串、集、排序集、列表、哈希、位图、hyperloglog、地理空间索引 |
| \$1 不包括已弃用、已达到或即将到期的版本。 |
为集群选择引擎后，建议您使用该引擎的最新版本。有关更多信息，请参阅 [受支持的节点类型](CacheNodes.SupportedTypes.md)。
# Valkey 或 Redis OSS 的在线迁移
使用在线迁移，您可以将数据从 Amazon EC2 上的自托管开源 Valkey 或 Redis OSS 迁移到 Amazon ElastiCache。
这指的是从自托管实例迁移到 ElastiCache 服务。有关在 ElastiCache 上从 Redis OSS 升级到 Valkey 的信息，请参阅[升级引擎版本，包括跨引擎升级升级引擎版本](VersionManagement.HowTo.md)。
**注意**
在 r6gd 节点类型上运行的 ElastiCache 无服务器缓存或集群不支持在线迁移。
## 概览
要将数据从 Amazon EC2 上运行的开源 Valkey 或 Redis OSS 迁移到 Amazon ElastiCache，需要使用现有或新创建的 Amazon ElastiCache 部署。该部署必须具有准备好进行迁移的配置。它还应该符合所需的配置，包括实例类型、分片数量和副本数量等属性。
在线迁移设计用于从 Amazon EC2 上自托管的开源 Valkey 或 Redis OSS 到 ElastiCache 的数据迁移，而不是 ElastiCache 集群之间的数据迁移。
**重要**
我们强烈建议您完整阅读以下部分，然后再开始在线迁移过程。
在调用 `StartMigration` API 操作或 AWS CLI 命令时，将开始迁移。迁移 Valkey 或 Redis OSS（已禁用集群模式）集群时，迁移过程会使 ElastiCache（兼容 Valkey 或 Redis OSS）集群的主节点成为源 Valkey 或 Redis OSS 主节点的副本。迁移 Valkey 或 Redis OSS（已启用集群模式）集群时，迁移过程会使每个 ElastiCache 分片的主节点成为源集群的拥有相同槽的对应分片的副本。
在客户端更改准备就绪后，调用 `CompleteMigration` API 操作。此 API 操作将您的 ElastiCache 部署提升到具有主节点和副本节点（在适用时）的主 Valkey 或 Redis OSS 部署。现在，您可以重新导向客户端应用程序以开始将数据写入到 ElastiCache。在整个迁移过程中，您可以通过在 Valkey 节点和 ElastiCache 主节点上运行 [valkey-cli INFO](https://valkey.io/commands/info) 命令来查看复制状态。
## 迁移步骤
以下主题简要说明了迁移数据的过程：
+ [准备源和目标以进行迁移](Migration-Prepare.md)
+ [测试数据迁移](Migration-Test.md)
+ [开始迁移](Migration-Initiate.md)
+ [验证数据迁移进度](Migration-Verify.md)
+ [完成数据迁移](Migration-Complete.md)
# 准备源和目标以进行迁移
通过这些步骤，您可以准备将数据从 EC2 上的自托管 Valkey 或 Redis 源迁移到 ElastiCache，或者从 Redis OSS 集群迁移到 ElastiCache Valkey 集群。
这指的是从自托管实例迁移到 ElastiCache 服务。有关在 ElastiCache 上从 Redis OSS 升级到 Valkey 的信息，请参阅[升级引擎版本，包括跨引擎升级升级引擎版本](VersionManagement.HowTo.md)。
您必须确保已经满足了下面提到的所有四个先决条件，才能开始从 ElastiCache 控制台、API 或 AWS CLI 迁移数据。
**准备源和目标 Valkey 或 Redis OSS 节点以进行迁移**
1. 确定目标 ElastiCache 部署，并确保您可以将数据迁移到该部署。
现有或新创建的 ElastiCache 部署应满足以下要求才能进行迁移：
+ 它使用的是 Valkey 或 Redis OSS 5.0.6 或更高版本。
+ 它未启用传输中加密。
+ 它已启用多可用区。
+ 它具有足够的可用内存以容纳 Valkey 或 Redis OSS 集群中的数据。要配置正确的保留内存设置，请参阅[管理 Valkey 和 Redis OSS 的预留内存](redis-memory-management.md)。
+ 对于已禁用集群模式，您可以直接从 Valkey 或 Redis OSS 2.8.21 及更高版本迁移到 Valkey 或 Redis OSS 5.0.6 及更高版本（使用 CLI），或迁移到 Valkey 或 Redis OSS 5.0.6 及以后版本（使用 CLI 或控制台）。对于已启用集群模式，您可以直接从任何已启用集群模式的 Valkey 或 Redis 版本迁移到 Redis OSS 5.0.6 及更高版本（使用 CLI），或迁移到 Redis OSS 5.0.6 及以后版本（使用 CLI 或控制台）。
+ 源和目标中的分片数量相匹配。
+ 它不是全局数据存储的一部分。
+ 它已禁用数据分层。
1. 确保开源 Valkey 或 Redis OSS 与 ElastiCache 部署的配置兼容。
至少，目标 ElastiCache 部署中的所有以下内容应与 Valkey 或 Redis OSS 配置兼容才能进行复制：
+ 集群不应启用 AUTH。
+ 配置 `protected-mode` 应设置为 `no`。
+ 如果在 Valkey 或 Redis OSS 配置中具有 `bind` 配置，应对其进行更新以允许来自 ElastiCache 节点的请求。
+ ElastiCache 节点和 Valkey 或 Redis OSS 集群上的逻辑数据库数量应该相同。该值是在 Valkey 或 Redis OSS 配置中使用 `databases` 设置的。
+ 不应重命名执行数据修改的 Valkey 或 Redis OSS 命令来使数据复制成功完成。例如 `sync`、`psync`、`info`、`config`、`command` 和 `cluster`。
+ 要将数据从 Valkey 或 Redis OSS 集群复制到 ElastiCache，请确保具有足够的 CPU 和内存以处理这一额外负载。该负载来自于 Valkey 或 Redis OSS 集群创建并通过网络传输到 ElastiCache 节点的 RDB 文件。
+ 源集群上的所有 Valkey 或 Redis OSS 实例都应在同一个端口上运行。
1. 执行以下操作，以确保实例可以连接到 ElastiCache：
+ 确保每个实例的 IP 地址是私有的。
+ 在与实例上的 Valkey 或 Redis OSS 相同的虚拟私有云（VPC）中分配或创建 ElastiCache 部署（建议）。
+ 如果 VPC 不同，请设置 VPC 对等以允许集群之间的访问。有关 VPC 对等的更多信息，请参阅[用于访问 Amazon VPC 中的 ElastiCache 缓存的访问模式](elasticache-vpc-accessing.md)。
+ 附加到 Valkey 或 Redis OSS 实例的安全组应允许来自 ElastiCache 节点的入站流量。
1. 在数据迁移完成后，确保应用程序可以将流量传送到 ElastiCache 节点。有关更多信息，请参阅 [用于访问 Amazon VPC 中的 ElastiCache 缓存的访问模式](elasticache-vpc-accessing.md)。
# 测试数据迁移
在满足所有先决条件后，您可以使用 AWS 管理控制台、ElastiCache API 或 AWS CLI 验证迁移设置。下面显示了使用 CLI 的示例。
使用以下参数调用 `test-migration` 命令以测试迁移：
+ `--replication-group-id` – 数据要迁移到的复制组的 ID。
+ `--customer-node-endpoint-list` – 应从中迁移数据的端点的列表。列表应该只有一个元素。
以下是一个使用 CLI 的示例。
```
aws elasticache test-migration --replication-group-id test-cluster --customer-node-endpoint-list "Address='10.0.0.241',Port=6379"
```
ElastiCache 将在不进行任何实际数据迁移的情况下验证迁移设置。
# 开始迁移
在满足所有先决条件后，您可以使用 AWS 管理控制台、ElastiCache API 或 AWS CLI 开始迁移数据。如果启用集群模式，当插槽迁移有所不同时，将在实时迁移之前执行重新分片。下面显示了使用 CLI 的示例。
**注意**
我们建议使用 `TestMigration` API 来验证迁移设置。但这完全是可选的。
可以使用以下参数调用 `start-migration` 命令以开始进行迁移：
+ `--replication-group-id` – 目标 ElastiCache 复制组的标识符
+ `--customer-node-endpoint-list` – 具有 DNS 或 IP 地址以及运行源 Valkey 或 Redis OSS 集群的端口的端点列表。对于禁用集群模式和启用集群模式，列表只能使用一个元素。如果启用了链式复制，则端点可能指向副本，而不是 Valkey 或 Redis OSS 集群中的主节点。
以下是一个使用 CLI 的示例。
```
aws elasticache start-migration --replication-group-id test-cluster --customer-node-endpoint-list "Address='10.0.0.241',Port=6379"
```
当您运行此命令时，ElastiCache 主节点（在每个分片中）会将自己配置成为您的 Valkey 或 Redis OSS 实例的副本（在启用集群的 redis 中拥有相同插槽的相应分片中）。ElastiCache 集群的状态将变为**正在迁移**，并开始将数据从 Valkey 或 Redis OSS 实例迁移到 ElastiCache 主节点。根据 Valkey 或 Redis OSS 实例上的数据大小和负载，迁移可能需要一段时间才能完成。您可以在 Valkey 实例和 ElastiCache 主节点上运行 [valkey-cli INFO](https://valkey.io/commands/info) 命令来检查迁移进程。
在成功复制后，写入到 Valkey 或 Redis OSS 实例的所有数据都将传播到 ElastiCache 集群。您可以使用 ElastiCache 节点执行读取操作。不过，您无法写入到 ElastiCache 集群。如果 ElastiCache 主节点连接了其他副本节点，这些副本节点将继续从 ElastiCache 主节点中进行复制。这样，Valkey 或 Redis OSS 集群中的所有数据将复制到 ElastiCache 集群中的所有节点。
如果 ElastiCache 主节点无法成为 Valkey 或 Redis OSS 实例的副本，则它会重试几次，然后最终将自身重新提升回为主节点。ElastiCache 集群的状态将变为 **available（可用）**，并发送有关启动迁移失败的复制组事件。要解决此类故障，请检查以下内容：
+ 查看复制组事件。使用事件中的任何特定信息修复迁移失败。
+ 如果事件未提供任何特定信息，请确保您遵循[准备源和目标以进行迁移](Migration-Prepare.md)中的准则。
+ 确保 VPC 和子网的路由配置允许 ElastiCache 节点和 Valkey 或 Redis OSS 实例之间的流量。
+ 确保附加到 Valkey 或 Redis OSS 实例的安全组允许来自 ElastiCache 节点的入站流量。
+ 检查实例的 Valkey 或 Redis OSS 日志，以获取有关特定于复制的失败的更多信息。
# 验证数据迁移进度
在数据迁移开始后，您可以执行以下操作以跟踪其进度：
+ 在 ElastiCache 主节点上验证 `INFO` 命令中的 Valkey 或 Redis OSS `master_link_status` 是否为 `up`。您还可以在 ElastiCache 控制台中找到该信息。选择集群，然后在 **CloudWatch metrics**（CloudWatch 指标）下观察 **Primary Link Health Status**（主链接运行状况）。在该值达到 1 后，数据就会同步。
+ 您可以在 Valkey 或 Redis OSS 实例上运行 `INFO` 命令来查看 ElastiCache 副本是否具有**在线**状态。这样做还会提供有关复制滞后的信息。
+ 对 Valkey 或 Redis OSS 实例使用 [CLIENT LIST](https://valkey.io/commands/client-list) 命令以验证低客户端输出缓冲区。
在数据迁移完成后，数据与进入 Valkey 或 Redis OSS 集群的主节点的任何新的写入保持同步。
# 完成数据迁移
在准备好切换到 ElastiCache 集群时，请使用具有以下参数的 `complete-migration` CLI 命令：
+ `--replication-group-id` – 复制组的标识符。
+ `--force` – 此值强制停止迁移，而不确保数据保持同步。
示例如下：
```
aws elasticache complete-migration --replication-group-id test-cluster
```
在运行该命令时，ElastiCache 主节点（在每个分片中）将停止从 Valkey 或 Redis OSS 实例进行复制，并将其提升为主实例。该提升通常在几分钟内完成。要确认提升为主节点，请检查事件 `Complete Migration successful for test-cluster`。此时，您可以将应用程序定向到 ElastiCache 写入和读取。ElastiCache 集群状态应从 **migrating（正在迁移）**变为 **available（可用）**。
如果提升为主实例失败，ElastiCache 主节点将继续从 Valkey 或 Redis OSS 实例中进行复制。ElastiCache 集群继续处于 **migrating（正在迁移）**状态，并发送有关该失败的复制组事件消息。要解决该故障，请查看以下内容：
+ 检查复制组事件。使用事件中的特定信息修复故障。
+ 您可能会收到有关数据不同步的事件消息。如果收到该消息，请确保 ElastiCache 主节点可以从 Valkey 或 Redis OSS 实例中复制，并且两者保持同步。如果仍要停止迁移，您可以使用 `—force` 选项运行前面的命令。
+ 如果正在替换其中一个 ElastiCache 节点，您可能会收到事件消息。在完成替换后，您可以重新尝试完成迁移步骤。
# 使用控制台执行联机数据迁移
您可以使用 AWS 管理控制台将数据从您的集群迁移到 Valkey 或 Redis OSS 集群。
**使用控制台执行联机数据迁移**
1. 登录到控制台并打开 ElastiCache 控制台 ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/home/home))。
1. 创建新的 Valkey 或 Redis OSS 集群，或选择现有集群。确保集群满足以下要求：
+ 引擎版本应为 Valkey 7.2 及更高版本或者 Redis OSS 5.0.6 或更高版本。
+ 集群不应启用 AUTH。
+ 配置 `protected-mode` 应设置为 `no`。
+ 如果在 Valkey 或 Redis OSS 配置中具有 `bind` 配置，应对其进行更新以允许来自 ElastiCache 节点的请求。
+ ElastiCache 节点和您的 Valkey 或 Redis OSS 集群的数据库数量应该相同。该值是在引擎配置中使用 `databases` 设置的。
+ 不应重命名执行数据修改的 Valkey 或 Redis OSS 命令来使数据复制成功完成。
+ 要将数据从 Valkey 或 Redis OSS 集群复制到 ElastiCache，请确保具有足够的 CPU 和内存以处理这一额外负载。该负载来自于 Valkey 或 Redis OSS 集群创建并通过网络传输到 ElastiCache 节点的 RDB 文件。
+ 集群处于 **available (可用)** 状态。
1. 选择您的集群后，在 **Actions（操作）**中选择 **Migrate Data from Endpoint（从端点迁移数据）**。
1. 在**从端点迁移数据**对话框中，输入 Valkey 或 Redis OSS 集群可用的 IP 地址和端口。
**重要**
IP 地址必须准确。如果未正确输入地址，迁移将失败。
1. 选择 **Start Migration (开始迁移)**。
在集群开始迁移时，它将变为 **Modifying (正在修改)** 状态，然后变为 **Migrating (正在迁移)** 状态。
1. 在导航窗格上选择 **Events (事件)** 以监视迁移进度。
在迁移过程中的任何时候，您都可以停止迁移。为此，选择您的集群，然后在 **Actions（操作）**中选择 **Stop Data Migration（停止数据迁移）**。然后，集群将变为 **Available (可用)** 状态。
如果迁移成功，集群将变为 **Available (可用)** 状态，并且事件日志显示以下内容：
`Migration operation succeeded for replication group ElastiCacheClusterName.`
如果迁移失败，集群将变为 **Available (可用)** 状态，并且事件日志显示以下内容：
`Migration operation failed for replication group ElastiCacheClusterName.`
# 为 ElastiCache 选择区域和可用区
您可以通过使用对应的端点指定区域和可用区，为您的 ElastiCache 集群提供更高的可扩展性和可靠性。
AWS 云计算资源存储在具有高度可用性的数据中心设施中。为了提供额外的扩展性和可靠性，这些数据中心设施位于不同的物理位置。这些位置按照*区域*和*可用区*进行分类。
AWS 区域是指大型、分布范围广泛的单独地理位置。可用区是 AWS 区域中的不同位置，旨在隔离其他可用区中的故障。它们提供与同一 AWS 区域中不同可用区之间的低成本、低延迟网络连接。
**重要**
每一个区域都是完全独立的。您启动的任何 ElastiCache 活动（例如，创建集群）仅可在您当前的默认区域中运行。
若要在特定地区创建或使用集群，请使用相应的区域服务端点。有关服务端点，请参阅[支持的区域和端点](#SupportedRegions)。
![\[图片： 区域和可用区\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-RegionsAndAZs.png)
*区域和可用区*
**Topics**
+ [可用区注意事项（Memcached）](#CacheNode.Memcached.AvailabilityZones)
+ [找到您的节点](#RegionsAndAZs.AZMode)
+ [支持的区域和端点](#SupportedRegions)
+ [将 Local Zones 与 ElastiCache 结合使用](Local_zones.md)
+ [将 Outposts 与 ElastiCache](ElastiCache-Outposts.md)
## 可用区注意事项（Memcached）
将 Memcached 节点分配到一个区域内的多个可用区有助于保护您免受灾难性故障（如可用区内断电）的影响。
**无服务器缓存**
ElastiCache 无服务器缓存会创建跨多个可用区的高可用性缓存。在创建无服务器集群时，您可以指定来自不同可用区和相同 VPC 的子网，否则 ElastiCache 会自动从您的默认 VPC 中选择子网。
**设计您自己的 ElastiCache for Memcached 集群**
一个 Memcached 集群最多可拥有 300 个节点。向 Memcached 集群创建节点或添加节点时，您可以为所有节点指定单一可用区、允许 ElastiCache 为所有节点选择单一可用区、为每个节点指定可用区或允许 ElastiCache 为每个节点选择一个可用区。当您将新节点添加到现有 Memcached 群集时，可以在不同的可用区中创建新节点。创建缓存节点后，无法修改其可用区。
如果您希望单一可用区集群中的集群将其节点分配到多个可用区中，ElastiCache 可以在各个可用区中创建新节点。然后，您可以删除部分或全部原始缓存节点。我们建议采用此方法。
**将 Memcached 节点从单一可用区迁移到多个可用区**
1. 通过在所需的可用区中创建新的缓存节点来修改您的集群。在您的请求中，执行以下操作：
+ 将 `AZMode`（CLI：`- -az-mode`）设置为 `cross-az`。
+ 将 `NumCacheNodes`（CLI：`- -num-cache-nodes`）设置为当前活动缓存节点数加上您要创建的新缓存节点数。
+ 将 `NewAvailabilityZones`（CLI：`- -new-availability-zones`）设置为要在其中创建新缓存节点的区域列表。要让 ElastiCache 确定每个新节点的可用区，请不要指定列表。
+ 将 `ApplyImmediately`（CLI：`- -apply-immediately`）设置为真。
**注意**
如果您未使用自动发现，请确保使用新的缓存节点端点更新客户端应用程序。
继续执行下一步之前，请确保 Memcached 节点已完全创建且可用。
1. 通过删除原始可用区中不再需要的节点来修改您的集群。在您的请求中，执行以下操作：
+ 将 `NumCacheNodes`（CLI：`- -num-cache-nodes`）设置为应用此修改后所需的活动缓存节点数。
+ 将 `CacheNodeIdsToRemove`（CLI：`- -nodes-to-remove`）设置为要从集群中删除的缓存节点列表。
列出的缓存节点 ID 的数量必须等于当前活动节点的数量减去`NumCacheNodes`。
+ （可选）将 `ApplyImmediately`（CLI：`- -apply-immediately`）设置为真。
如果您未将 `ApplyImmediately`（CLI：`- -apply-immediately`）置为真，则将在您的下一个维护时段中进行节点删除。
## 找到您的节点
Amazon ElastiCache 支持在单一或多个可用区（AZ）中找到集群的所有节点。此外，如果您选择在多个可用区中找到节点（建议方式），ElastiCache 将允许您为每个节点选择可用区，也可以让 ElastiCache 为您选择可用区。
通过在不同的可用区内放置节点，可排除某个可用区内的故障（如停电）导致整个系统失败的可能性。测试表明，将所有节点放置在同一个可用区与跨多个可用区放置节点相比并不存在显著延迟。
您可以在创建集群时为每个节点指定可用区，或在修改现有集群时通过添加节点来指定可用区。在创建集群期间为每个节点指定可用区时，该可用区必须在该子网组中可用。有关更多信息，请参阅下列内容：
+ [为 Memcached 创建集群](Clusters.Create-mc.md)
+ [创建 Valkey 或 Redis OSS 集群](Clusters.Create.md)
+ [修改 ElastiCache 集群](Clusters.Modify.md)
+ [向 ElastiCache 集群添加节点](Clusters.AddNode.md)
## 支持的区域和端点
Amazon ElastiCache 提供多个 AWS 区域。这意味着，您可在满足您要求的位置启动 ElastiCache 集群。例如，您可以在最靠近您客户的 AWS 区域或者满足某些法律要求的特定 AWS 区域中启动。
从设计而言，每个区域都与其他区域完全隔离。在每个区域中有多个可用区（AZ）。ElastiCache 无服务器缓存可自动跨多个可用区复制数据（`us-west-1` 除外，此时在两个可用区中复制数据），以实现高可用性。在设计自己的 ElastiCache 集群时，您可以选择在不同可用区中启动节点，从而实现容错能力。有关区域和可用区的更多信息，请参阅此主题顶部的[为 ElastiCache 选择区域和可用区](#RegionsAndAZs)。
**支持 ElastiCache 的区域**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/RegionsAndAZs.html)
某些区域只支持部分节点类型。有关 AWS 区域支持的节点类型的表，请参阅 [AWS区域支持的节点类型](CacheNodes.SupportedTypes.md#CacheNodes.SupportedTypesByRegion)。
大多数区域支持通过创建接口 VPC 端点（使用 AWS PrivateLink）在您的 VPC 与 ElastiCache API 端点之间建立私有连接。有关更多信息，请参阅 [ElastiCache API 和接口 VPC 终端节点 (AWS PrivateLink)](elasticache-privatelink.md)。
有关按区域划分的 AWS 产品和服务表，请参阅[按区域划分的产品和服务](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/)。
# 将 Local Zones 与 ElastiCache 结合使用
*本地扩展区* 是在地理位置上靠近用户的 AWS 区域的扩展。您可以通过创建新子网并将其分配到 Local Zones，将任何 Virtual Private Cloud (VPC) 从 AWS 父区域扩展到 Local Zones。当您在本地扩展区中创建子网时，VPC 也会扩展到该本地扩展区。本地扩展区中的子网与 VPC 中其他子网的运行相同。
通过使用 Local Zones，您可以将 ElastiCache 集群等资源放置在靠近用户的多个位置。
创建 ElastiCache 集群时，您可以选择 Local Zones 中的子网。Local Zones 有自己的 Internet 连接并支持 Direct Connect。因此，在本地扩展区中创建的资源可以通过非常低延迟的通信为本地用户提供服务。有关更多信息，请参阅 [AWSLocal Zones](https://aws.amazon.com/about-aws/global-infrastructure/localzones/)。
本地扩展区由 AWS 区域代码后跟一个指示位置的标识符表示，例如 `us-west-2-lax-1a`。
目前，可用的 Local Zones 是 `us-west-2-lax-1a` 和 `us-west-2-lax-1b`。
以下限制适用于 Local Zones 的 ElastiCache：
+ 不支持全局数据存储。
+ 不支持在线迁移。
+ Local Zones 目前支持以下节点类型：
+ 最新一代：
**M5 节点类型：**、`cache.m5.large`、`cache.m5.xlarge`、`cache.m5.2xlarge`、`cache.m5.4xlarge`、`cache.m5.12xlarge``cache.m5.24xlarge`
**R5 节点类型：**、`cache.r5.large`、`cache.r5.xlarge`、`cache.r5.2xlarge`、`cache.r5.4xlarge`、`cache.r5.12xlarge``cache.r5.24xlarge`
**T3 节点类型：**、`cache.t3.micro`、`cache.t3.small``cache.t3.medium`
## 启用本地区域
1. 在 Amazon EC2 控制台中启用本地扩展区。
有关更多信息，请参阅 *Amazon EC2 用户指南（适用于 Linux 实例）* 中的[启用 Local Zones](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#enable-zone-group)。
1. 在本地扩展区中创建子网。
有关更多信息，请参阅 *Amazon VPC 用户指南* 中的[在 VPC 中创建子网](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet)。
1. 在 Local Zones 中创建 ElastiCache 子网组。
创建 ElastiCache 子网组时，请为 Local Zones 选择可用区组。
有关更多信息，请参阅 [创建子网组](SubnetGroups.Creating.md)。
1. 创建一个使用 Local Zones 中的 ElastiCache 子网的 ElastiCache for Memcached 集群。
有关更多信息，请参阅 [创建 Memcached 集群（控制台）](Clusters.Create-mc.md#Clusters.Create.CON.Memcached)。
1. 创建一个使用 Local Zones 中的 ElastiCache 子网的 ElastiCache for Redis OSS 集群。有关更多信息，请参阅下列主题之一：
+ [创建 Valkey（已禁用集群模式）集群（控制台）](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ [创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
# 将 Outposts 与 ElastiCache
你可以将AWS Outposts 与配合使用。 ElastiCacheOutposts 是一项完全托管的服务，可将AWS基础架构 APIs、服务和工具扩展到客户驻地。通过提供对AWS托管基础设施的本地访问权限，AWS Outposts使客户能够使用与AWS区域相同的编程接口在本地构建和运行应用程序，同时使用本地计算和存储资源来降低延迟和满足本地数据处理需求。Outpost 是部署在客户现场的AWS计算和存储容量池。AWS将此容量作为AWS区域的一部分进行运营、监控和管理。您可以在 Outpost 上创建子网，并在创建集群等AWS ElastiCache 资源时指定子网。
**注意**
在此版本中，以下限制适用：
ElastiCache for Outposts 仅支持 M5 和 R5 节点系列。
多可用区（不支持跨站点复制）。
不支持实时迁移。
不支持本地快照。
无法启用引擎日志和慢速日志。
ElastiCache on Outposts 不支持 CoIP。
ElastiCache 以下区域不支持 for Outposts：cn-northeast-1、cn-northeast-1 和 ap-northeast-3。
## 在主机上使用 Outposts ElastiCache
1. 登录AWS 管理控制台并打开 ElastiCache 控制台，网址为[ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。
1. 在导航窗格中，选择 **Valkey 缓存**、**Redis OSS 缓存**或 **Memcached 缓存**。
1. 如果您选择了 **Valkey 缓存**，请选择**创建 Valkey 缓存**。如果您选择了 **Redis OSS 缓存**，请选择**创建 Redis OSS 缓存**。如果您选择了 **Memcached 缓存**，请选择**创建 Memcached 缓存**。
1. 在**集群设置**下，选择**设计自己的缓存**和**集群缓存**。将**集群模式**设置为**已禁用**。然后输入缓存的名称和可选描述。
1. 对于位置，选择**本地**。
1. 在“本地”部分中，您将看到 **Outpost ID** 字段。输入集群运行位置的 ID。
**集群设置**下的所有其他设置都可以保持默认状态。
1. 在**连接**中，选择**创建新的子网组**，然后输入 **VPC ID**。其余内容保留默认状态，然后选择**下一步**。
### 配置本地选项
您可以选择一个可用的 Outpost 来添加集群，如果没有可用的 Outposts，您也可以选择使用以下步骤创建一个新的集群：
**在 **On-Premises options（本地选项）**下：**
1. 根据您的首选引擎，在 **Valkey 设置**、**Redis OSS 设置**或 **Memcached 设置**下，进行以下设置：
1. **名称**：为集群输入名称。
1. **描述**：输入集群的描述。
1. **引擎版本兼容性**：引擎版本基于 Outpost 区域AWS
1. **端口**：对于 Valkey 或 Redis OSS，接受默认端口 6379。对于 Memcached，接受默认端口 11211。如果您想使用其他端口，请键入相应的端口号。
1. **Parameter group（参数组）**：使用下拉菜单选择默认或自定义参数组。
1. **Node Type（节点类型）**：可用实例基于 Outposts 可用性。如果使用 Valkey 或 Redis OSS，适用于 Outposts 的 Porting Assistant for .NET 仅支持 M5 和 R5 节点系列。从下拉列表中，选择 **Outposts**，然后选择要用于此集群的可用节点类型。然后选择 **Save（保存）**。
1. **Number of Replicas（副本数）**：输入要为此复制组创建的只读副本数。您必须至少有一个只读副本，但不超过五个。默认值是 2。
只读副本的自动生成的名称与主群集名称的模式相同，末尾添加一个破折号和连续三位数字，并以 `-002` 开头。例如，如果您的复制组名为 `MyGroup`，辅助集群的名称将为 `MyGroup-002`、`MyGroup-003`、`MyGroup-004`、`MyGroup-005`、`MyGroup-006`。
1. 在**连接**下：
1. **Subnet Group（子网组）**：从列表中选择 **Create new（创建新子网组）**。
+ **Name（名称）**：输入子网组的名称
+ **Description（描述）**：输入子网组的描述
+ **VPC ID**：VPC ID 应与 Outpost VPC 一致。如果您选择的 VPC 在 Outpost IDs s 上没有子网，则列表将返回空白。
+ **Availability Zone or Outpost（可用区或 Outpost）**：选择您正在使用的 Outpost。
+ **Subnet ID（子网 ID）**：选择可用于 Outpost 的子网 ID。如果没有可 IDs 用的子网，则需要创建子网。有关更多信息，请参阅[创建子网](https://docs.aws.amazon.com/outposts/latest/userguide/launch-instance.html#create-subnet)。
1. 选择**创建**。
### 查看 Outpost 集群详细信息
在列表页面上，选择属于AWS Outpost 的集群，并在查看**集群详细信息**时注意以下事项：
+ **可用区域**：这将使用 ARN（Amazon 资源名称）和AWS资源编号表示前哨基地。
+ **前哨基地名称**：前AWS哨基地的名称。
## 在 CLI 中使用 Outposts AWS
您可以使用AWS Command Line Interface(AWS CLI) 从命令行控制多项AWS服务，并通过脚本自动执行这些服务。您可以使用AWS CLI 进行临时（一次性）操作。
### 正在下载和配置AWS CLI
它们可以在 Windows、macOS 或 Linux 上AWS CLI运行。按照以下步骤下载和并对其进行配置。
**下载、安装和配置 CLI**
1. 在[AWS命令行界面](https://aws.amazon.com/cli)网页上下载AWS CLI。
1. 按照*AWS Command Line Interface用户指南*中有关[安装AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) 和[配置AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) 的说明进行操作。
### 在 Outposts 中使用AWS CLI
使用以下 CLI 操作创建使用 Outposts 的集群：
+ [create-cache-cluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/CommandLineReference/CLIReference-cmd-CreateCacheCluster.html)— 使用此操作，`outpost-mode`参数接受一个值，该值指定集群中的节点是在单个 Outpost 中创建的，还是在多个 Outposts 中创建的。
**注意**
目前仅支持 `single-outpost` 模式。
```
aws elasticache create-cache-cluster \
--cache-cluster-id cluster id \
--outpost-mode single-outpost \
```