本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。 # Amazon ElastiCache 中的数据安全性 为了帮助确保数据安全，Amazon ElastiCache 和 Amazon EC2 提供了禁止未经授权来访问服务器上数据的机制。 Amazon ElastiCache for Memcached 还为运行 Memcached 版本 1.6.12 或更高版本的缓存中的数据提供了加密功能。 Amazon ElastiCache（兼容 Valkey 或 Redis OSS）面向运行 Valkey 7.2 或更高版本以及 Redis OSS 3.2.6（已计划终止生命周期，请参阅 [Redis OSS 版本生命周期终止计划](engine-versions.md#deprecated-engine-versions)）、4.0.10 或更高版本的缓存，为其中的数据提供了可选加密功能。Amazon ElastiCache 还支持使用 IAM 或 Valkey 和 Redis OSS AUTH 对用户进行身份验证，以及使用基于角色的访问控制（RBAC）对用户操作进行授权。 + 传输中加密可对从一个位置移动到另一个位置的数据进行加密，例如在集群中的节点之间或在缓存与应用程序之间移动数据。 + 静态加密可在同步和备份操作期间对磁盘上的数据进行加密。 ElastiCache 支持使用 IAM 以及 Valkey 和 Redis OSS 命令对用户进行身份验证，以及使用基于角色的访问控制（RBAC）对用户进行操作授权。 ![\[图片：ElastiCache for Valkey 和 ElastiCache for Redis OSS 安全性示意图\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/images/ElastiCache-Redis-Secure-Compliant.png) *ElastiCache for Valkey 和 ElastiCache for Redis OSS 安全性示意图* **Topics** + [ElastiCache 传输中加密 (TLS)](in-transit-encryption.md) + [静态加密 ElastiCache](at-rest-encryption.md) + [身份验证和授权](auth-redis.md) # ElastiCache 传输中加密 (TLS) 为了帮助保护您的数据安全，Amazon ElastiCache 和 Amazon EC2 提供了防止未经授权访问您在服务器上的数据的机制。通过提供传输中加密功能， ElastiCache 为您提供一种工具，用于在数据从一个位置移动到另一个位置时帮助保护数据。 所有 Valkey 或 Redis OSS 无服务器缓存均启用了传输中加密。对于基于节点的集群，在创建复制组时，您可将参数 `TransitEncryptionEnabled` 设置为 `true`（CLI：`--transit-encryption-enabled`），以此在复制组中启用传输中加密。无论您是使用、还是 ElastiCache API 创建复制组AWS 管理控制台AWS CLI，都可以执行此操作。 所有无服务器缓存均启用了传输中加密。对于基于节点的集群，在使用 `CreateCacheCluster`（CLI：`create-cache-cluster`）操作创建集群时，您可以将参数 `TransitEncryptionEnabled` 设置为 `true`（CLI：`--transit-encryption-enabled`），从而在集群上启用传输中加密。 **Topics** + [传输中加密概览](#in-transit-encryption-overview) + [传输中加密的条件（Valkey 和 Redis OSS）](#in-transit-encryption-constraints) + [传输中加密的条件（Memcached）](#in-transit-encryption-constraints) + [传输中加密最佳实践](#in-transit-encryption-best-practices) + [更多 Valkey 和 Redis OSS 选项](#in-transit-encryption-see-also) + [为 Memcached 启用传输中加密](#in-transit-encryption-enable-existing-mc) + [启用传输中加密](in-transit-encryption-enable.md) + [使用 valkey-cli 连接到使用传输中加密的 ElastiCache（Valkey）或 Amazon ElastiCache for Redis OSS](connect-tls.md) + [使用 Python 在基于节点的 Redis OSS 集群上启用传输中加密](in-transit-encryption-enable-python.md) + [启用传输中加密时的最佳实践](enable-python-best-practices.md) + [使用 Openssl 连接到启用了传输中加密的节点（Memcached）](#in-transit-encryption-connect-mc) + [使用 Java 创建 TLS Memcached 客户端](#in-transit-encryption-connect-java) + [使用 PHP 创建 TLS Memcached 客户端](#in-transit-encryption-connect-php-mc) ## 传输中加密概览 Amazon ElastiCache 传输中加密是一项功能，可让您在数据从一个位置传输到另一个地点时，在最脆弱的地方提高数据的安全性。由于在端点加密和解密数据时需要进行一些处理，因此启用传输中加密会对性能产生一些影响。应对使用和不使用传输中加密的数据进行基准测试，以确定对使用案例的性能影响。 ElastiCache 传输中加密实现了以下功能： + **加密客户端连接**：客户端与缓存节点的连接采用 TLS 加密。 + **加密服务器连接**：对集群中在节点之间移动的数据进行了加密。 + **服务器身份验证** – 客户端可通过身份验证确定它们连接到正确的服务器。 + **客户端身份验证** – 使用 Valkey 或 Redis OSS AUTH 功能，服务器可以对客户端进行身份验证。 ## 传输中加密的条件（Valkey 和 Redis OSS） 在规划基于节点的集群实施时，应牢记以下对 Amazon ElastiCache 传输中加密的限制： + 在运行以下 Redis 版本的复制组上支持传输中加密：Valkey 7.2 和更高版本，以及 Redis OSS 3.2.6、4.0.10 和更高版本。 + 运行 Valkey 7.2 和更高版本以及 Redis OSS 7 和更高版本的复制组支持修改现有集群的传输中加密设置。 + 只有在 Amazon VPC 中运行的复制组支持传输中加密。 + 运行以下节点类型的复制组不支持传输中加密：M1、M2。 有关更多信息，请参阅 [受支持的节点类型](CacheNodes.SupportedTypes.md)。 + 通过显式将参数 `TransitEncryptionEnabled` 设置为 `true` 可启用传输中加密。 + 确保您的缓存客户端支持 TLS 连接，并且您已在客户端配置中启用传输中加密。 + 从2026年1月26日起，Valkey 7.2及以上版本以及Redis OSS版本6及以上版本AWS将支持的最低TLS版本更新 ElastiCache 为1.2。 ElastiCache 客户必须在该日期之前更新其客户端软件。此更新可帮助您满足安全、合规和监管需求。 ## 传输中加密的条件（Memcached） 在规划基于节点的集群实施时，应牢记以下对 Amazon ElastiCache 传输中加密的限制： + 在运行 Memcached 1.6.12 及更高版本的集群上支持传输中加密。 + 传输中加密支持传输层安全性协议（TLS）版本 1.2 和 1.3。 + 只有在 Amazon VPC 中运行的集群才支持传输中加密。 + 运行以下节点类型的复制组不支持传输中加密：M1、M2、M3、R3、T2。 有关更多信息，请参阅 [受支持的节点类型](CacheNodes.SupportedTypes.md)。 + 通过显式将参数 `TransitEncryptionEnabled` 设置为 `true` 可启用传输中加密。 + 只有在创建集群时，才能在集群上启用传输中加密。无法通过修改集群来开启和关闭传输中加密。 + 确保您的缓存客户端支持 TLS 连接，并且您已在客户端配置中启用传输中加密。 ## 传输中加密最佳实践 + 由于在端点加密和解密数据时需要进行一些处理，因此实现传输中加密会降低性能。使用自己的数据，对传输中加密进行基准测试，然后与不加密情况进行比较，以确定其对实现性能的影响。 + 由于创建新连接的成本可能非常高，您可以通过保留 TLS 连接来减小传输中加密对性能的影响。 ## 更多 Valkey 和 Redis OSS 选项 有关 Valkey 和 Redis OSS 可用选项的更多信息，请参阅以下链接。 + [静态加密 ElastiCache](at-rest-encryption.md) + [使用 Valkey 和 Redis OSS AUTH 命令进行身份验证](auth.md) + [基于角色的访问控制（RBAC）](Clusters.RBAC.md) + [Amazon VPCs 与 ElastiCache 安全](VPCs.md) + [适用于亚马逊的身份和访问管理 ElastiCache](IAM.md) ## 为 Memcached 启用传输中加密 要在使用AWS管理控制台创建 Memcached 集群时启用传输中加密，请进行以下选择： + 选择 Memcached 作为引擎。 + 选择 1.6.12 或更高的引擎版本。 + 在 **Encryption in transit**（传输中加密）下，选择 **Enable**（启用）。 有关 step-by-step流程，请参阅[创建 Valkey 或 Redis OSS 集群](Clusters.Create.md)。 # 启用传输中加密 所有无服务器缓存均启用了传输中加密。在基于节点的集群上，您可以使用、CLI 或 AP AWS I 启用传输AWS 管理控制台中加密。 ElastiCache ## 使用启用传输中加密AWS 管理控制台 ### 使用为新的基于节点的集群启用传输中加密AWS 管理控制台 在设计自己的集群时，采用“轻松创建”方法的“开发/测试”和“生产”配置均启用了传输中加密。在您选择自己的配置时，请进行以下选择： + 选择 3.2.6、4.0.10 或更高的引擎版本。 + 单击**传输中加密**选项的**启用**旁边的复选框。 有关 step-by-step流程，请参阅以下内容： + [创建 Valkey（已禁用集群模式）集群（控制台）](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs) + [创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster) ### 使用为现有的基于节点的集群启用传输中加密AWS 管理控制台 启用传输中加密分为两步，您必须先将传输加密模式设置为 `preferred`。此模式允许您的 Valkey 或 Redis OSS 客户端使用加密和未加密的连接进行连接。将所有 Valkey 或 Redis OSS 客户端迁移为使用加密连接后，您可以修改集群配置以将传输加密模式设置为 `required`。将传输加密模式设置为 `required` 将删除所有未加密的连接，并且仅允许加密连接。 **将**传输加密模式**设置为**首选**** 1. 登录AWS 管理控制台并打开 Amazon ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。 1. 从左侧导航窗格上列出的 ElastiCache**资源**中选择 **Valkey 缓****存或 Redis OSS** 缓存。 1. 选择要更新的缓存。 1. 选择 **Actions**（操作）下拉列表，然后选择 **Modify**（修改）。 1. 在 **Security**（安全）部分的 **Encryption in transit**（传输中加密）下，选择 **Enable**（启用）。 1. 选择 **Preferred**（首选）作为 **Transit encryption mode**（传输加密模式）。 1. 选择 **Preview changes**（预览更改），然后保存更改。 将所有 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. 选择要更新的缓存。 1. 选择 **Actions**（操作）下拉列表，然后选择 **Modify**（修改）。 1. 在 **Security**（安全）部分中，选择 **Required**（必需）作为 **Transit encryption mode**（传输加密模式）。 1. 选择 **Preview changes**（预览更改），然后保存更改。 ## 使用启用传输中加密AWS CLI 要在使用AWS CLI创建 Valkey 或 Redis OSS 复制组时启用传输中加密，请使用参数 `transit-encryption-enabled`。 ### 在新的 Valkey 或 Redis OSS 基于节点的集群（已禁用集群模式）上启用传输中加密（CLI） 使用AWS CLI操作`create-replication-group`和以下参数创建具有启用传输中加密的副本的 Valkey 或 Redis OSS 复制组： **关键参数：** + **--engine** – 必须为 `valkey` 或 `redis`。 + **--engine-version** – 如果引擎为 Redis OSS，则必须为 3.2.6、4.0.10 或更高版本。 + **--transit-encryption-enabled** – 必填项。如果要启用传输中加密，还必须为 `--cache-subnet-group` 参数提供值。 + **--num-cache-clusters** – 必须至少为 1。此参数的最大值为 6。 有关更多信息，请参阅下列内容： + [从头创建 Valkey 或 Redis OSS（已禁用集群模式）复制组（AWS CLI）](Replication.CreatingReplGroup.NoExistingCluster.Classic.md#Replication.CreatingReplGroup.NoExistingCluster.Classic.CLI) + [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html) ### 在新的 Valkey 或 Redis OSS 基于节点的集群（已启用集群模式）上启用传输中加密（CLI） 使用AWS CLI操作`create-replication-group`和以下参数创建启用传输中加密的 Valkey 或 Redis OSS（已启用集群模式）复制组： **关键参数：** + **--engine** – 必须为 `valkey` 或 `redis`。 + **--engine-version** – 如果引擎为 Redis OSS，则必须为 3.2.6、4.0.10 或更高版本。 + **--transit-encryption-enabled** – 必填项。如果要启用传输中加密，还必须为 `--cache-subnet-group` 参数提供值。 + 使用以下参数集之一指定复制组的节点组配置： + **--num-node-groups** – 指定此复制组中的分片数（节点组）。此参数的最大值为 500。 **--replicas-per-node-group** – 指定每个节点组中的副本节点数。此处指定的值适用于此复制组中的所有分片。此参数的最大值为 5。 + **--node-group-configuration** – 分别指定每个分片的配置。 有关更多信息，请参阅下列内容： + [从头开始创建 Valkey 或 Redis OSS（已启用集群模式）复制组（AWS CLI）](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI) + [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html) ### 使用AWS CLI为现有集群启用传输中加密 启用传输中加密分为两步，您必须先将传输加密模式设置为 `preferred`。此模式允许您的 Valkey 或 Redis OSS 客户端使用加密和未加密的连接进行连接。将所有 Valkey 或 Redis OSS 客户端迁移为使用加密连接后，您可以修改集群配置以将传输加密模式设置为 `required`。将传输加密模式设置为 `required` 将删除所有未加密的连接，并且仅允许加密连接。 使用AWS CLI操作`modify-replication-group`和以下参数更新已禁用传输中加密的 Valkey 或 Redis OSS（已启用集群模式）复制组。 **启用传输中加密** 1. 使用以下参数设置为 transit-encryption-mode `preferred` + **--transit-encryption-enabled** – 必填项。 + **--transit-encryption-mode** - 必须设置为 `preferred`。 1. 使用以下参数设置 transit-encryption-mode为：`required` + **--transit-encryption-enabled** – 必填项。 + **--transit-encryption-mode** - 必须设置为 `required`。 # 使用 valkey-cli 连接到使用传输中加密的 ElastiCache（Valkey）或 Amazon ElastiCache for Redis OSS 要访问启用了传输中加密的 ElastiCache for Redis OSS 缓存中的数据，您可以使用利用安全套接字层（SSL）的客户端。您也可以在 Amazon Linux 和 Amazon Linux 2 上使用具有 TLS/SSL 的 valkey-cli。如果您的客户端不支持 TLS，则可以在客户端主机上，使用 `stunnel` 命令创建连接到 Redis OSS 节点的 SSL 隧道。 ## 与 Linux 的加密连接 要使用 valkey-cli 连接到 Amazon Linux 2 或 Amazon Linux 上启用了传输中加密的 Valkey 或 Redis OSS 集群，请按照以下步骤操作。 1. 下载并编译 valkey-cli 实用工具。此实用工具包含在 Valkey 软件发布版中。 1. 在 EC2 实例的命令提示符处，键入适合您所用 Linux 版本的相应命令。 ** Amazon Linux 2** 如果使用的是 Amazon Linux 2，请输入以下命令： ``` sudo yum -y install openssl-devel gcc wget https://github.com/valkey-io/valkey/archive/refs/tags/7.2.6.tar.gz tar xvzf valkey-7.2.6.tar.gz cd valkey-7.2.6 make distclean make valkey-cli BUILD_TLS=yes sudo install -m 755 src/valkey-cli /usr/local/bin/ ``` **Amazon Linux** – 如果使用的是 Amazon Linux，请输入以下命令： ``` sudo yum install gcc jemalloc-devel openssl-devel tcl tcl-devel clang wget 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 valkey-cli CC=clang BUILD_TLS=yes sudo install -m 755 src/valkey-cli /usr/local/bin/ ``` 在 Amazon Linux 上，您可能还需要执行以下额外步骤： ``` sudo yum install clang CC=clang make sudo make install ``` 1. 下载并安装 valkey-cli 实用程序后，建议运行可选的 `make-test` 命令。 1. 要连接到已启用加密和身份验证的集群，请输入以下命令： ``` valkey-cli -h Primary or Configuration Endpoint --tls -a 'your-password' -p 6379 ``` **注意** 如果您在 Amazon Linux 2023 上安装了 redis6，那么现在可以使用命令 `redis6-cli`，而不是使用 `valkey-cli`： ``` redis6-cli -h Primary or Configuration Endpoint --tls -p 6379 ``` ## 与 stunnel 的加密连接 要使用 valkey-cli 连接到使用 stunnel 进行传输中加密的 Redis OSS 集群，请按以下步骤操作。 1. 使用 SSH 连接到您的客户端并安装 `stunnel`。 ``` sudo yum install stunnel ``` 1. 运行以下命令创建并同时编辑文件 `'/etc/stunnel/valkey-cli.conf'`，以下面提供的输出为模板，将一个 ElastiCache for Redis OSS 集群端点添加到一个或多个连接参数。 ``` vi /etc/stunnel/valkey-cli.conf fips = no setuid = root setgid = root pid = /var/run/stunnel.pid debug = 7 delay = yes options = NO_SSLv2 options = NO_SSLv3 [valkey-cli] client = yes accept = 127.0.0.1:6379 connect = primary.ssltest.wif01h.use1.cache.amazonaws.com:6379 [valkey-cli-replica] client = yes accept = 127.0.0.1:6380 connect = ssltest-02.ssltest.wif01h.use1.cache.amazonaws.com:6379 ``` 在此示例中，配置文件具有两个连接，即 `valkey-cli` 和 `valkey-cli-replica`。参数设置如下所示： + **client** 设置为 yes（是）以指定此 Stunnel 实例是客户端。 + **accept** 设置为客户端 IP。在此示例中，主 IP 设置为端口 6379 上的 Redis OSS 默认 127.0.0.1。副本必须调用另一个端口并设置为 6380。您可以使用临时端口 1024-65535。有关更多信息，请参阅 *Amazon VPC 用户指南*中的[临时端口](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html#VPC_ACLs_Ephemeral_Ports)。 + **connect** 设置为 Redis OSS 服务器端点。有关更多信息，请参阅 [查找 ElastiCache 中的缓存连接端点](Endpoints.md)。 1. 启动 `stunnel`。 ``` sudo stunnel /etc/stunnel/valkey-cli.conf ``` 使用 `netstat` 命令确认隧道已启动。 ``` sudo netstat -tulnp | grep -i stunnel tcp 0 0 127.0.0.1:6379 0.0.0.0:* LISTEN 3189/stunnel tcp 0 0 127.0.0.1:6380 0.0.0.0:* LISTEN 3189/stunnel ``` 1. 使用隧道的本地端点连接到加密的 Redis OSS 节点。 + 如果在创建 ElastiCache for Redis OSS 集群时未使用 AUTH 密码，此示例将在 Amazon Linux 上使用 valkey-cli 通过其完整路径连接到 ElastiCache for Redis OSS 服务器： ``` /home/ec2-user/redis-7.2.5/src/valkey-cli -h localhost -p 6379 ``` 如果在创建 Redis OSS 集群时未使用 AUTH 密码，此示例将在 Amazon Linux 上使用 valkey-cli 通过其完整路径连接到 Redis OSS 服务器： ``` /home/ec2-user/redis-7.2.5/src/valkey-cli -h localhost -p 6379 -a my-secret-password ``` 或 + 将目录更改为 redis-7.2.5 并执行以下操作： 如果在创建 ElastiCache for Redis OSS 集群时未使用 AUTH 密码，此示例将在 Amazon Linux 上使用 valkey-cli 通过其完整路径连接到 ElastiCache for Redis OSS 服务器： ``` src/valkey-cli -h localhost -p 6379 ``` 如果在创建 Redis OSS 集群时未使用 AUTH 密码，此示例将在 Amazon Linux 上使用 valkey-cli 通过其完整路径连接到 Valkey 或 Redis OSS 服务器： ``` src/valkey-cli -h localhost -p 6379 -a my-secret-password ``` 此示例使用 Telnet 连接到 Valkey Redis OSS 服务器。 ``` telnet localhost 6379 Trying 127.0.0.1... Connected to localhost. Escape character is '^]'. auth MySecretPassword +OK get foo $3 bar ``` 1. 要停止并关闭 SSL 隧道，请对 Stunnel 过程执行 `pkill` 操作。 ``` sudo pkill stunnel ``` # 使用 Python 在基于节点的 Redis OSS 集群上启用传输中加密 以下指南将演示如何在 Redis OSS 7.0 集群上启用传输中加密，该集群最初是在禁用传输中加密的情况下创建的。在此过程中，TCP 和 TLS 客户端将继续与集群通信，无需停机。 Boto3 将从环境变量中获取它所需的凭证（`aws_access_key_id`、`aws_secret_access_key` 和 `aws_session_token`）。这些凭证将提前粘贴到一个 bash 终端中，我们将在该同一个终端中运行 `python3` 来处理本指南中显示的 Python 代码。以下示例中的代码是在将用于在其中创建 ElastiCache Redis OSS 集群的同一 VPC 中启动的 EC2 实例中的进程。 **注意** 以下示例使用 boto3 SDK 进行 ElastiCache 管理操作（创建集群或用户），使用 redis-p redis-py-cluster y/ 进行数据处理。 您必须至少使用 boto3 版本 (=\$1) 1.26.39，才能通过集群修改 API 使用在线 TLS 迁移。 ElastiCache 仅支持 Valkey 版本 7.2 及以上或 Redis OSS 版本 7.0 或更高版本的集群的在线 TLS 迁移。因此，如果您的集群运行的是 7.0 之前的 Redis OSS 版本，则需要升级集群的 Redis OSS 版本。有关版本差异的更多信息，请参阅[Redis OSS 的主要引擎版本行为和兼容性差异](VersionManagementConsiderations.md)。 **Topics** + [定义将启动 ElastiCache Valkey 或 Redis OSS 集群的字符串常量](#enable-python-define-constants) + [为集群配置定义类](#enable-python-define-classes) + [定义一个表示集群本身的类](#enable-python-define-classes-cluster) + [（可选）创建一个包装器类来演示客户端与 Valkey 或 Redis OSS 集群的连接](#enable-python-create-wrapper) + [创建主函数，用于演示更改传输中加密配置的过程](#enable-python-main-function) ## 定义将启动 ElastiCache Valkey 或 Redis OSS 集群的字符串常量 首先，让我们定义一些简单的 Python 字符串常量，用于保存创建 ElastiCache 集群所需的AWS实体的名称`security-group`，例如`Cache Subnet group`、和 a `default parameter group`。所有这些AWS实体都必须事先在您愿意使用的区域的AWS账户中创建。 ``` #Constants definitions SECURITY_GROUP = "sg-0492aa0a29c558427" CLUSTER_DESCRIPTION = "This cluster has been launched as part of the online TLS migration user guide" EC_SUBNET_GROUP = "client-testing" DEFAULT_PARAMETER_GROUP_REDIS_7_CLUSTER_MODE_ENABLED = "default.redis7.cluster.on" ``` ## 为集群配置定义类 现在，让我们定义一些简单的 Python 类，这些类将表示集群的配置，而这些配置将保留有关集群的元数据，例如 Valkey 或 Redis OSS 版本、实例类型以及是启用还是禁用传输中加密（TLS）。 ``` #Class definitions class Config: def __init__( self, instance_type: str = "cache.t4g.small", version: str = "7.0", multi_az: bool = True, TLS: bool = True, name: str = None, ): self.instance_type = instance_type self.version = version self.multi_az = multi_az self.TLS = TLS self.name = name or f"tls-test" def create_base_launch_request(self): return { "ReplicationGroupId": self.name, "TransitEncryptionEnabled": self.TLS, "MultiAZEnabled": self.multi_az, "CacheNodeType": self.instance_type, "Engine": "redis", "EngineVersion": self.version, "CacheSubnetGroupName": EC_SUBNET_GROUP , "CacheParameterGroupName": DEFAULT_PARAMETER_GROUP_REDIS_7_CLUSTER_MODE_ENABLED , "ReplicationGroupDescription": CLUSTER_DESCRIPTION, "SecurityGroupIds": [SECURITY_GROUP], } class ConfigCME(Config): def __init__( self, instance_type: str = "cache.t4g.small", version: str = "7.0", multi_az: bool = True, TLS: bool = True, name: str = None, num_shards: int = 2, num_replicas_per_shard: int = 1, ): super().__init__(instance_type, version, multi_az, TLS, name) self.num_shards = num_shards self.num_replicas_per_shard = num_replicas_per_shard def create_launch_request(self) -> dict: launch_request = self.create_base_launch_request() launch_request["NumNodeGroups"] = self.num_shards launch_request["ReplicasPerNodeGroup"] = self.num_replicas_per_shard return launch_request ``` ## 定义一个表示集群本身的类 现在，让我们定义一些简单的 Python 类来表示 ElastiCache Valkey 或 Redis OSS 集群本身。该类将有一个 client 字段，其中包含一个 boto3 客户端，用于 ElastiCache 管理操作，例如创建集群和查询 API。 ElastiCache ``` import botocore.config import boto3 # Create boto3 client def init_client(region: str = "us-east-1"): config = botocore.config.Config(retries={"max_attempts": 10, "mode": "standard"}) init_request = dict() init_request["config"] = config init_request["service_name"] = "elasticache" init_request["region_name"] = region return boto3.client(**init_request) class ElastiCacheClusterBase: def __init__(self, name: str): self.name = name self.elasticache_client = init_client() def get_first_replication_group(self): return self.elasticache_client.describe_replication_groups( ReplicationGroupId=self.name )["ReplicationGroups"][0] def get_status(self) -> str: return self.get_first_replication_group()["Status"] def get_transit_encryption_enabled(self) -> bool: return self.get_first_replication_group()["TransitEncryptionEnabled"] def is_available(self) -> bool: return self.get_status() == "available" def is_modifying(self) -> bool: return self.get_status() == "modifying" def wait_for_available(self): while True: if self.is_available(): break else: time.sleep(5) def wait_for_modifying(self): while True: if self.is_modifying(): break else: time.sleep(5) def delete_cluster(self) -> bool: self.elasticache_client.delete_replication_group( ReplicationGroupId=self.name, RetainPrimaryCluster=False ) def modify_transit_encryption_mode(self, new_transit_encryption_mode: str): # generate api call to migrate the cluster to TLS preffered or to TLS required self.elasticache_client.modify_replication_group( ReplicationGroupId=self.name, TransitEncryptionMode=new_transit_encryption_mode, TransitEncryptionEnabled=True, ApplyImmediately=True, ) self.wait_for_modifying() class ElastiCacheClusterCME(ElastiCacheClusterBase): def __init__(self, name: str): super().__init__(name) @classmethod def launch(cls, config: ConfigCME = None) -> ElastiCacheClusterCME: config = config or ConfigCME() print(config) new_cluster = ElastiCacheClusterCME(config.name) launch_request = config.create_launch_request() new_cluster.elasticache_client.create_replication_group(**launch_request) new_cluster.wait_for_available() return new_cluster def get_configuration_endpoint(self) -> str: return self.get_first_replication_group()["ConfigurationEndpoint"]["Address"] #Since the code can throw exceptions, we define this class to make the code more readable and #so we won't forget to delete the cluster class ElastiCacheCMEManager: def __init__(self, config: ConfigCME = None): self.config = config or ConfigCME() def __enter__(self) -> ElastiCacheClusterCME: self.cluster = ElastiCacheClusterCME.launch(self.config) return self.cluster def __exit__(self, exc_type, exc_val, exc_tb): self.cluster.delete_cluster() ``` ## （可选）创建一个包装器类来演示客户端与 Valkey 或 Redis OSS 集群的连接 现在，让我们为 `redis-py-cluster` 客户端创建一个包装器类。这个包装器类将支持在集群中预先填充一些密钥，然后执行随机重复的 `get` 命令。 **注意** 这是一个可选步骤，但它简化了后面步骤中出现的主函数的代码。 ``` import redis improt random from time import perf_counter_ns, time class DowntimeTestClient: def __init__(self, client): self.client = client # num of keys prefilled self.prefilled = 0 # percent of get above prefilled self.percent_get_above_prefilled = 10 # nil result expected when get hit above prefilled # total downtime in nano seconds self.downtime_ns = 0 # num of success and fail operations self.success_ops = 0 self.fail_ops = 0 self.connection_errors = 0 self.timeout_errors = 0 def replace_client(self, client): self.client = client def prefill_data(self, timelimit_sec=60): end_time = time() + timelimit_sec while time() < end_time: self.client.set(self.prefilled, self.prefilled) self.prefilled += 1 # unsuccesful operations throw exceptions def _exec(self, func): try: start_ns = perf_counter_ns() func() self.success_ops += 1 elapsed_ms = (perf_counter_ns() - start_ns) // 10 ** 6 # upon succesful execution of func # reset random_key to None so that the next command # will use a new random key self.random_key = None except Exception as e: elapsed_ns = perf_counter_ns() - start_ns self.downtime_ns += elapsed_ns # in case of failure- increment the relevant counters so that we will keep track # of how many connection issues we had while trying to communicate with # the cluster. self.fail_ops += 1 if e.__class__ is redis.exceptions.ConnectionError: self.connection_errors += 1 if e.__class__ is redis.exceptions.TimeoutError: self.timeout_errors += 1 def _repeat_exec(self, func, seconds): end_time = time() + seconds while time() < end_time: self._exec(func) def _new_random_key_if_needed(self, percent_above_prefilled): if self.random_key is None: max = int((self.prefilled * (100 + percent_above_prefilled)) / 100) return random.randint(0, max) return self.random_key def _random_get(self): key = self._new_random_key_if_needed(self.percent_get_above_prefilled) result = self.client.get(key) # we know the key was set for sure only in the case key < self.prefilled if key < self.prefilled: assert result.decode("UTF-8") == str(key) def repeat_get(self, seconds=60): self._repeat_exec(self._random_get, seconds) def get_downtime_ms(self) -> int: return self.downtime_ns // 10 ** 6 def do_get_until(self, cond_check): while not cond_check(): self.repeat_get() # do one more get cycle once condition is met self.repeat_get() ``` ## 创建主函数，用于演示更改传输中加密配置的过程 现在，让我们定义主函数，它将执行以下操作： 1. 使用 boto3 ElastiCache 客户端创建集群。 1. 初始化将使用不带 TLS 的清晰 TCP 连接来连接到集群的 `redis-py-cluster` 客户端。 1. `redis-py-cluster` 客户端在集群中预先填充一些数据。 1. boto3 客户端将触发 TLS 从无 TLS 迁移到首选 TLS。 1. 当将集群迁移到 TLS `Preferred` 时，`redis-py-cluster` TCP 客户端将向集群发送重复的 `get` 操作，直到迁移完成。 1. 完成向 TLS `Preferred` 的迁移后，我们将断言集群支持传输中加密。之后，我们将创建一个使用 TLS 连接到集群的 `redis-py-cluster` 客户端。 1. 我们将使用新的 TLS 客户端和旧的 TCP 客户端发送一些 `get` 命令。 1. boto3 客户端将触发 TLS 从 TLS `Preferred` 迁移到需要 TLS。 1. 当集群需要迁移到 TLS 时， redis-py-clusterTLS 客户端将向集群发送重复的`get`操作，直到迁移完成。 ``` import redis def init_cluster_client( cluster: ElastiCacheClusterCME, prefill_data: bool, TLS: bool = True) -> DowntimeTestClient: # we must use for the host name the cluster configuration endpoint. redis_client = redis.RedisCluster( host=cluster.get_configuration_endpoint(), ssl=TLS, socket_timeout=0.25, socket_connect_timeout=0.1 ) test_client = DowntimeTestClient(redis_client) if prefill_data: test_client.prefill_data() return test_client if __name__ == '__main__': config = ConfigCME(TLS=False, instance_type="cache.m5.large") with ElastiCacheCMEManager(config) as cluster: # create a client that will connect to the cluster with clear tcp connection test_client_tcp = init_cluster_client(cluster, prefill_data=True, TLS=False) # migrate the cluster to TLS Preferred cluster.modify_transit_encryption_mode(new_transit_encryption_mode="preferred") # do repeated get commands until the cluster finishes the migration to TLS Preferred test_client_tcp.do_get_until(cluster.is_available) # verify that in transit encryption is enabled so that clients will be able to connect to the cluster with TLS assert cluster.get_transit_encryption_enabled() == True # create a client that will connect to the cluster with TLS connection. # we must first make sure that the cluster indeed supports TLS test_client_tls = init_cluster_client(cluster, prefill_data=True, TLS=True) # by doing get commands with the tcp client for 60 more seconds # we can verify that the existing tcp connection to the cluster still works test_client_tcp.repeat_get(seconds=60) # do get commands with the new TLS client for 60 more seconds test_client_tcp.repeat_get(seconds=60) # migrate the cluster to TLS required cluster.modify_transit_encryption_mode(new_transit_encryption_mode="required") # from this point the tcp clients will be disconnected and we must not use them anymore. # do get commands with the TLS client until the cluster finishes migartion to TLS required mode. test_client_tls.do_get_until(cluster.is_available) ``` # 启用传输中加密时的最佳实践 ## 在启用传输中加密之前：确保您正确处理 DNS 记录 **注意** 在此过程中，我们正在更改和删除旧端点。不正确地使用端点可能会导致 Valkey 或 Redis OSS 客户端使用旧的和已删除的端点，从而使其无法连接到集群。 当集群从无 TLS 迁移到首选 TLS 时，旧的集群配置端点 DNS 记录会被保留，并将以不同的格式生成新的集群配置端点 DNS 记录。启用 TLS 的集群与禁用 TLS 的集群所使用的 DNS 记录格式不同。当集群配置为 `encryption mode: Preferred` 时，ElastiCache 将保留这两种 DNS 记录，以便应用程序和其他 Valkey 或 Redis OSS 客户端可以在它们之间切换。在 TLS 迁移过程中，DNS 记录发生以下更改： ### 启用传输中加密时发生的 DNS 记录更改的描述 **对于 CME 集群** 当集群设置为“传输加密模式：首选”时： + 禁用 TLS 的集群的原始集群配置端点将保持活动状态。将集群从 TLS 加密模式“无”重新配置为“首选”时，不会出现停机。 + 当集群设置为首选 TLS 模式时，将生成新的 TLS Valkey 或 Redis OSS 端点。这些新端点将解析为与旧端点（非 TLS）相同的 IP。 + 新的 TLS Valkey 或 Redis OSS 配置端点将在 ElastiCache 控制台和对 `describe-replication-group` API 的响应中公开。 当集群设置为“传输加密模式：需要”时： + 将删除未启用 TLS 的旧端点。TLS 集群端点将不会停机。 + 您可以从 ElastiCache 控制台或 `describe-replication-group` API 检索新的 `cluster-configuration-endpoint` 文件。 **对于启用了自动失效转移或禁用了自动失效转移的 CMD 集群** 当复制组设置为“传输加密模式：首选”时： + 未启用 TLS 的集群的原始主端点和读取器端点将保持活动状态。 + 当集群设置为 TLS `Preferred` 模式时，将生成新的 TLS 主端点和读取器端点。此新端点将解析为与旧端点（非 TLS）相同的 IP。 + 新的主端点和读取器端点将在 ElastiCache 控制台和对 `describe-replication-group` API 的响应中公开。 当复制组设置为“传输加密模式：需要”时： + 将删除旧的非 TLS 主端点和读取器端点。TLS 集群端点将不会停机。 + 您可以从 ElastiCache 控制台或 `describe-replication-group` API 检索新的主端点和读取器端点。 ### DNS 记录的建议用法 **对于 CME 集群** + 在应用程序代码中使用集群配置端点，而不是每节点 DNS 记录。不建议直接使用每节点 DNS 名称，因为这些名称在迁移过程中会发生变化，这会导致应用程序代码与集群的连接中断。 + 不要在应用程序中对集群配置端点进行硬编码，因为该端点在此过程中会发生变化。 + 在应用程序中对集群配置端点进行硬编码是一种不好的做法，因为在此过程中可能会对端点进行更改。传输中加密完成后，使用 `describe-replication-group` API 查询集群配置端点，如上所示（粗体），然后从此时起使用从响应中获得的 DNS。 **对于启用了自动失效转移的 CMD 集群** + 在应用程序代码中使用主端点和读取器端点而不是每节点 DNS 名称，因为将集群从无 TLS 迁移到首选 TLS 时，会删除旧的每节点 DNS 名称并生成新的 DNS 名称。不建议直接使用每节点 DNS 名称，因为将来您可能会向集群添加副本。此外，启用自动失效转移后，ElastiCache 服务会自动更改主集群和副本的角色，建议使用主端点和读取器端点来帮助您跟踪这些更改。最后，使用读取器端点将帮助您在集群中的副本之间平均分配从副本进行的读取操作。 + 在应用程序中对主端点和读取器端点进行硬编码是不好的做法，因为在 TLS 迁移过程中可能会对端点进行更改。完成向首选 TLS 的迁移更改后，使用 describe-replication-group API 查询主端点和读取器端点，然后从此时起使用从响应中获得的 DNS。这样，您将能够以动态方式跟踪端点的变化。 **对于禁用了自动失效转移的 CMD 集群** + 在应用程序的代码中使用主端点和读取器端点，而不是每节点 DNS 名称。禁用自动失效转移时，启用自动失效转移时由 ElastiCache 服务自动管理的扩缩、修补、失效转移以及其他过程将改为由您完成。这使您能够更轻松地手动跟踪不同的端点。由于在将集群从无 TLS 迁移到首选 TLS 时，会删除旧的每节点 DNS 名称并生成新的每节点 DNS 名称，因此请勿直接使用每节点 DNS 名称。这一点是强制性的，以便客户端能够在 TLS 迁移期间连接到集群。此外，在使用读取器端点时会在副本之间均匀分布读取操作，并且在集群中添加或删除副本时会跟踪 DNS 记录，因此您将受益匪浅。 + 在应用程序中对集群配置端点进行硬编码是一种不好的做法，因为在 TLS 迁移过程中可能会对端点进行更改。 ## 在传输中加密期间：注意迁移过程何时完成 传输加密模式的更改并非立即生效，而可能需要一些时间。对于大型集群而言，这种情况尤其如此。只有当集群完成向首选 TLS 的迁移后，集群才能接受和提供 TCP 和 TLS 连接。因此，在传输中加密完成之前，不应创建尝试与集群建立 TLS 连接的客户端。 有几种方法可以在传输中加密成功完成或失败时获得通知：（未显示在上面的代码示例中）： + 使用 SNS 服务在加密完成时收到通知 + 使用将在加密完成后发出事件的 `describe-events` API + 在 ElastiCache 控制台中看到一条表明加密已完成的消息 您还可以在应用程序中实现逻辑以了解加密是否已完成。在上面的示例中，我们看到了几种确保集群完成迁移的方法： + 等到迁移过程开始（集群状态更改为“正在修改”），然后等到修改完成（集群状态变回为“可用”） + 通过查询 `describe-replication-group` API 断言集群已将 `transit_encryption_enabled` 设置为 True。 ### 启用传输中加密后：确保正确配置了您使用的客户端 当集群处于首选 TLS 模式时，您的应用程序应建立与集群的 TLS 连接并仅使用这些连接。这样，在启用传输中加密时，应用程序就不会出现停机。您可以使用 SSL 部分下的 info 命令，确保与 Valkey 或 Redis OSS 引擎之间没有更清晰的 TCP 连接。 ``` # SSL ssl_enabled:yes ssl_current_certificate_not_before_date:Mar 20 23:27:07 2017 GMT ssl_current_certificate_not_after_date:Feb 24 23:27:07 2117 GMT ssl_current_certificate_serial:D8C7DEA91E684163 tls_mode_connected_tcp_clients:0 (should be zero) tls_mode_connected_tls_clients:100 ``` ## 使用 Openssl 连接到启用了传输中加密的节点（Memcached） 要访问启用传输中加密 ElastiCache 的 Memcached 节点的数据，您需要使用支持安全套接字层 (SSL) 的客户端。您也可以在 Amazon Linux 和 Amazon Linux 2 上使用 Openssl s\$1client。 使用 Openssl s\$1client 连接到 Amazon Linux 2 或 Amazon Linux 上启用了传输中加密的 Memcached 集群： ``` /usr/bin/openssl s_client -connect memcached-node-endpoint:memcached-port ``` ## 使用 Java 创建 TLS Memcached 客户端 要在 TLS 模式下创建客户端，请执行以下操作以使用相应的方法初始化客户端 SSLContext： ``` import java.security.KeyStore; import javax.net.ssl.SSLContext; import javax.net.ssl.TrustManagerFactory; import net.spy.memcached.AddrUtil; import net.spy.memcached.ConnectionFactoryBuilder; import net.spy.memcached.MemcachedClient; public class TLSDemo { public static void main(String[] args) throws Exception { ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder(); // Build SSLContext TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); tmf.init((KeyStore) null); SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, tmf.getTrustManagers(), null); // Create the client in TLS mode connectionFactoryBuilder.setSSLContext(sslContext); MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster.fnjyzo.cfg.use1.cache.amazonaws.com:11211")); // Store a data item for an hour. client.set("theKey", 3600, "This is the data value"); } } ``` ## 使用 PHP 创建 TLS Memcached 客户端 要在 TLS 模式下创建客户端，请执行以下操作以使用相应的方法初始化客户端 SSLContext： ``` setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE); /* Add the memcached's cluster server/s */ $tls_client->addServer($server_endpoint, $server_port); /* Configure the client to use TLS */ if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) { echo $tls_client->getLastErrorMessage(), "\n"; exit(1); } /* Set your TLS context configurations values. * See MemcachedTLSContextConfig in memcached-api.php for all configurations */ $tls_config = new MemcachedTLSContextConfig(); $tls_config->hostname = '*.mycluster.fnjyzo.use1.cache.amazonaws.com'; $tls_config->skip_cert_verify = false; $tls_config->skip_hostname_verify = false; /* Use the created TLS context configuration object to create OpenSSL's SSL_CTX and set it to your client. * Note: These TLS context configurations will be applied to all the servers connected to this client. */ $tls_client->createAndSetTLSContext((array)$tls_config); /* test the TLS connection with set-get scenario: */ /* store the data for 60 seconds in the cluster. * The client will decide which cache host will store this item. */ if($tls_client->set('key', 'value', 60)) { print "Successfully stored key\n"; } else { echo "Failed to set key: ", $tls_client->getLastErrorMessage(), "\n"; exit(1); } /* retrieve the key */ if ($tls_client->get('key') === 'value') { print "Successfully retrieved key\n"; } else { echo "Failed to get key: ", $tls_client->getLastErrorMessage(), "\n"; exit(1); } ``` 有关使用 PHP 客户端的更多信息，请参阅 [安装适用于 PHP 的 ElastiCache Cluster Client](Appendix.PHPAutoDiscoverySetup.md)。 # 静态加密 ElastiCache 为了帮助保护您的数据安全，Amazon ElastiCache 和 Amazon S3 提供了不同的方法来限制对缓存中数据的访问。有关更多信息，请参阅[Amazon VPCs 与 ElastiCache 安全](VPCs.md)和[适用于亚马逊的身份和访问管理 ElastiCache](IAM.md)。 ElastiCache 静态加密是一项通过加密磁盘数据来提高数据安全性的功能。无服务器缓存上始终启用该功能。在启用后，它会对以下方面进行加密： + 同步、备份和交换操作期间的磁盘 + 存储在 Amazon S3 中的备份 在启用数据分层的集群中，存储在 SSDs （固态驱动器）上的数据始终处于加密状态。 ElastiCache 提供默认（服务托管）静态加密，并且能够在密钥[管理服务 (KMS) 中AWS使用您自己的对称客户托管 K](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) MS 密AWS钥。备份缓存后，在加密选项下，选择是使用默认加密密钥还是客户自主管理型密钥。有关更多信息，请参阅 [启用静态加密](#at-rest-encryption-enable)。 **重要** 在基于节点的现有 Valkey 或 Redis OSS 集群上启用静态加密，涉及到在现有的复制组上运行备份和还原**之后**删除该复制组。 静态加密只能在创建缓存时在缓存上启用。由于加密和解密数据时需要进行一些处理，因此启用静态加密会对这些操作期间的性能产生影响。应对使用和不使用静态加密的数据进行基准测试，以确定对使用案例的性能影响。 **Topics** + [静态加密条件](#at-rest-encryption-constraints) + [使用 KMS 中的客户托管密AWS钥](#using-customer-managed-keys-for-elasticache-security) + [启用静态加密](#at-rest-encryption-enable) + [另请参阅](#at-rest-encryption-see-also) ## 静态加密条件 在计划实施 ElastiCache 静态加密时，应牢记以下 ElastiCache 静态加密限制： + 在运行 Valkey 7.2 和更高版本以及 Redis OSS 版本 3.2.6（计划终止生命周期，请参阅 [Redis OSS 版本生命周期终止计划](engine-versions.md#deprecated-engine-versions)）、4.0.10 或更高版本的复制组上支持静态加密。 + 只有在 Amazon VPC 中运行的复制组支持静态加密。 + 只有运行以下节点类型的复制组才支持静态加密。 + R7g、R6gd、R6g、R5、R4、R3 + M7g、M6g、M5、M4、M3 + T4g、T3、T2 + C7gn 有关更多信息，请参阅 [受支持的节点类型](CacheNodes.SupportedTypes.md)。 + 通过将参数 `AtRestEncryptionEnabled` 明确设置为 `true` 可启用静态加密。 + 只有在创建复制组时才能在复制组中启用静态加密。无法通过修改复制组来开启和关闭静态加密。有关在现有复制组中实现静态加密的信息，请参阅[启用静态加密](#at-rest-encryption-enable)。 + 如果集群使用 r6gd 系列的节点类型，则无论是否启用静态加密，存储在 SSD 上的数据都会加密。 + 在AWS GovCloud (us-gov-east-1 和- us-gov-west 1) 区域中不提供使用客户托管密钥进行静态加密的选项。 + 如果集群使用的是 r6gd 系列中的节点类型，则存储在 SSD 上的数据将使用选定的客户托管AWS KMS 密钥进行加密（或区域中的AWS GovCloud 服务托管加密）。 + 使用 Memcached 时，只有无服务器缓存上支持静态加密。 + 使用 Memcached 时，使用客户托管密钥进行静态加密的选项不适用于AWS GovCloud (us-gov-east-1 和- us-gov-west 1) 区域。 在备份和节点同步操作期间，实施静态加密可能会降低性能。使用自己的数据，对静态加密进行基准测试，然后与不加密情况进行比较，以确定其对实现性能的影响。 ## 使用 KMS 中的客户托管密AWS钥 ElastiCache 支持对称客户托管AWS KMS 密钥（KMS 密钥）进行静态加密。客户管理的 KMS 密钥是您在AWS账户中创建、拥有和管理的加密密钥。有关更多信息，请参阅 *AWS Key Management Service 开发人员指南*中的 [AWS KMS 密钥](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#root_keys)。密钥必须先在AWS KMS 中创建，然后才能与一起使用 ElastiCache。 要了解如何创建AWS KMS 根密钥，请参阅[密*AWS钥管理服务开发人员指南*中的创建密钥](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html)。 ElastiCache 允许您与AWS KMS 集成。有关更多信息，请参阅 *AWS Key Management Service 开发人员指南*中的[使用授权](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)。无需客户采取任何措施即可启用 Amazon 与AWS KMS 的 ElastiCache 集成。 `kms:ViaService`条件密钥将AWS KMS 密钥（KMS 密钥）的使用限制为来自指定AWS服务的请求。要`kms:ViaService`与一起使用 ElastiCache，请在条件键值中包含两个 ViaService 名称：`elasticache.AWS_region.amazonaws.com`和`dax.AWS_region.amazonaws.com`。有关更多信息，请参阅 [kms: ViaService](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-via-service)。 您可以使用[AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)来跟踪 Amazon 代表您 ElastiCache 发送AWS Key Management Service的请求。与客户托管密钥AWS Key Management Service相关的所有API调用都有相应的 CloudTrail 日志。您还可以通过调用 [ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html)KMS API 来查看 ElastiCache 创建的授权。 使用客户自主管理型密钥对复制组进行加密后，复制组的所有备份都将按如下方式进行加密： + 使用与集群关联的客户自主管理型密钥对每日自动备份进行加密。 + 删除复制组时创建的最终备份也使用与复制组关联的客户自主管理型密钥进行加密。 + 默认情况下，使用与复制组关联的密钥对手动创建的备份进行加密。您可以通过选择其他客户自主管理型密钥来覆此行为。 + 复制备份将默认使用与源备份关联的客户自主管理型密钥。您可以通过选择其他客户自主管理型密钥来覆此行为。 **注意** 将备份导出到所选的 Amazon S3 存储桶时，无法使用客户自主管理型密钥。但是，导出到 Amazon S3 的所有备份都将使用[服务器端加密进行加密。](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html)您可以选择将备份文件复制到新的 S3 对象并使用客户自主管理型 KMS 密钥进行加密，将文件复制到使用 KMS 密钥通过默认加密设置的另一个 S3 存储桶，或者更改文件本身中的加密选项。 对于未使用客户自主管理型密钥进行加密的复制组的手动创建备份，您还可以使用客户自主管理型密钥对其进行加密。使用此选项，即使未在原始复制组上加密数据，也可以使用 KMS 密钥对存储在 Amazon S3 中的备份文件进行加密。 从备份还原允许您从可用的加密选项中进行选择，类似于创建新复制组时可用的加密选项。 + 如果删除密钥或[禁用](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html)密钥并为用于加密缓存的密钥[撤销授权](https://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html)，则缓存将变得不可恢复。换句话说，硬件故障后无法对其进行修改或恢复。AWS KMS 只有在等待至少七天后才会删除根密钥。删除密钥后，您可以使用其他客户自主管理型密钥创建备份以用于存档目的。 + 自动密钥轮换会保留您的AWS KMS 根密钥的属性，因此轮换不会影响您访问 ElastiCache 数据的能力。加密的 Amazon ElastiCache 缓存不支持手动密钥轮换，这包括创建新的根密钥和更新对旧密钥的所有引用。要了解更多信息，请参阅[密AWS钥管理服务开发人员指南中的轮换 KMS AWS](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) *密*钥。 + 使用 KMS 密钥加密 ElastiCache 缓存需要每个缓存获得一次授权。此授权在缓存的整个生命周期中使用。此外，在备份创建期间每个备份要使用一个授权。在创建备份后，此授权将停用。 + 有关AWS KMS 授权和限制的更多信息，请参阅《*AWS密钥管理服务开发者指南》*中的[限制](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html)。 ## 启用静态加密 所有无服务器缓存均启用了静态加密。 创建基于节点的集群时，您可以通过将参数 `AtRestEncryptionEnabled` 设置为 `true` 来启用静态加密。不能对现有复制组启用静态加密。 您可以在创建 ElastiCache 缓存时启用静态加密。您可以使用AWS 管理控制台AWS CLI、或 ElastiCache API 执行此操作。 在创建缓存时，您可以选取以下选项之一： + **默认** – 此选项使用服务管理的静态加密。 + **客户托管密钥**-此选项允许您提供来 ID/ARN 自AWS KMS 的密钥以进行静态加密。 要了解如何创建AWS KMS 根密钥，请参阅[密*AWS钥管理服务开发者指南*中的创建密钥](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) **Contents** + [使用启用静态加密AWS 管理控制台](#at-rest-encryption-enable-con) + [使用启用静态加密AWS CLI](#at-rest-encryption-enable-cli) ### 在基于节点的现有 Valkey 或 Redis OSS 集群上启用静态加密 只能在创建 Valkey 或 Redis OSS 复制组时启用静态加密。如果要对现有复制组启用静态加密，请执行以下操作。 **要对现有复制组启用静态加密** 1. 创建现有复制组的手动备份。有关更多信息，请参阅 [进行手动备份](backups-manual.md)。 1. 通过从备份中还原来创建新复制组。对新复制组启用静态加密。有关更多信息，请参阅 [从备份还原到新缓存](backups-restoring.md)。 1. 在您的应用程序中，将终端节点更新为新复制组的节点。 1. 删除旧复制组。有关更多信息，请参阅 [删除中的集群 ElastiCache](Clusters.Delete.md)或 [删除复制组](Replication.DeletingRepGroup.md)。 ### 使用启用静态加密AWS 管理控制台 #### 在无服务器缓存上启用静态加密（控制台） 所有无服务器缓存均启用了静态加密。默认情况下，使用AWS拥有的 KMS 密钥来加密数据。要选择自己的AWS KMS密钥，请进行以下选择： + 展开**默认设置**部分。 + 在**默认设置**部分下选择**自定义默认设置**。 + 在**安全**部分下选择**自定义您的安全设置**。 + 在**加密密钥**设置下选择**客户自主管理型密钥**。 + 在 **AWS KMS密钥**设置下选择一个密钥。 #### 在基于节点的集群上启用静态加密（控制台） 在设计自己的缓存时，采用“轻松创建”方法的“开发/测试”和“生产”配置均启用了使用**默认**密钥的静态加密。在您选择自己的配置时，请进行以下选择： + 选择 3.2.6、4.0.10 或更高版本作为引擎版本。 + 单击**静态加密**选项的**启用**旁边的复选框。 + 选择**默认密钥**或**客户自主管理型密钥**。 有关 step-by-step步骤，请参阅以下内容： + [创建 Valkey（已禁用集群模式）集群（控制台）](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs) + [创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster) ### 使用启用静态加密AWS CLI 要在使用创建 Valkey 或 Redis OSS 集群时启用静态加密AWS CLI，请在创建复制组时使用 *--at-rest-encryption-enabled* 参数。 #### 在 Valkey 或 Redis OSS（已禁用集群模式）集群上启用静态加密（CLI） 以下操作创建`my-classic-rg`包含三个节点 (*--*)、一个主节点和两个只读副本的 Valkey 或 Redis OSS（已禁用集群模式num-cache-clusters）复制组。已为此复制组 (*--at-rest-encryption-enabled*) 启用静态加密。 在对此复制组启用加密时，需要以下参数及其值： **关键参数** + **--engine**— 必须为 `valkey` 或 `redis`。 + **--engine-version** – 如果引擎为 Redis OSS，则必须为 3.2.6、4.0.10 或更高版本。 + **--at-rest-encryption-enabled** – 启用静态加密所必需的。 **Example 1：具有副本的 Valkey 或 Redis OSS（已禁用集群模式）集群** 对于 Linux、macOS 或 Unix： ``` aws elasticache create-replication-group \ --replication-group-id my-classic-rg \ --replication-group-description "3 node replication group" \ --cache-node-type cache.m4.large \ --engine redis \ --at-rest-encryption-enabled \ --num-cache-clusters 3 ``` 对于 Windows： ``` aws elasticache create-replication-group ^ --replication-group-id my-classic-rg ^ --replication-group-description "3 node replication group" ^ --cache-node-type cache.m4.large ^ --engine redis ^ --at-rest-encryption-enabled ^ --num-cache-clusters 3 ^ ``` 有关更多信息，请参阅以下内容： + [从头创建 Valkey 或 Redis OSS（已禁用集群模式）复制组（AWS CLI）](Replication.CreatingReplGroup.NoExistingCluster.Classic.md#Replication.CreatingReplGroup.NoExistingCluster.Classic.CLI) + [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)   #### 在 Valkey 或 Redis OSS（已启用集群模式）集群上启用静态加密（CLI） 以下操作创建`my-clustered-rg`包含三个节点组或分片 (*--*) 的 Valkey 或 Redis OSS（已启用集群模式）复制组。num-node-groups每个节点都有三个节点，一个主节点和两个只读副本 (*--replicas-per-node-group*)。已为此复制组 (*--at-rest-encryption-enabled*) 启用静态加密。 在对此复制组启用加密时，需要以下参数及其值： **关键参数** + **--engine**— 必须为 `valkey` 或 `redis`。 + **--engine-version** – 如果引擎为 Redis OSS，则必须为 4.0.10 或更高版本。 + **--at-rest-encryption-enabled** – 启用静态加密所必需的。 + **--cache-parameter-group** – 必须为 `default-redis4.0.cluster.on` 或派生自此值，以便为此集群启用复制组模式。 **Example 2：Valkey 或 Redis OSS（已启用集群模式）集群** 对于 Linux、macOS 或 Unix： ``` aws elasticache create-replication-group \ --replication-group-id my-clustered-rg \ --replication-group-description "redis clustered cluster" \ --cache-node-type cache.m3.large \ --num-node-groups 3 \ --replicas-per-node-group 2 \ --engine redis \ --engine-version 6.2 \ --at-rest-encryption-enabled \ --cache-parameter-group default.redis6.x.cluster.on ``` 对于 Windows： ``` aws elasticache create-replication-group ^ --replication-group-id my-clustered-rg ^ --replication-group-description "redis clustered cluster" ^ --cache-node-type cache.m3.large ^ --num-node-groups 3 ^ --replicas-per-node-group 2 ^ --engine redis ^ --engine-version 6.2 ^ --at-rest-encryption-enabled ^ --cache-parameter-group default.redis6.x.cluster.on ``` 有关更多信息，请参阅以下内容： + [从头开始创建 Valkey 或 Redis OSS（已启用集群模式）复制组（AWS CLI）](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI) + [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html) ## 另请参阅 + [Amazon VPCs 与 ElastiCache 安全](VPCs.md) + [适用于亚马逊的身份和访问管理 ElastiCache](IAM.md) # 身份验证和授权 AWS Identity and Access Management（IAM）是一项 Web 服务，可帮助您安全地控制对 AWS 资源的访问。ElastiCache 支持使用 IAM 以及 Valkey 和 Redis OSS 命令对用户进行身份验证，以及使用基于角色的访问控制（RBAC）对用户进行操作授权。 **Topics** + [基于角色的访问控制（RBAC）](Clusters.RBAC.md) + [使用 Valkey 和 Redis OSS AUTH 命令进行身份验证](auth.md) + [在 ElastiCache Valkey 或 Redis OSS 缓存上禁用访问控制](in-transit-encryption-disable.md) # 基于角色的访问控制（RBAC） 使用 [使用 Valkey 和 Redis OSS AUTH 命令进行身份验证](auth.md) 中描述的 Valkey 和 Redis OSS AUTH 命令，您可以使用基于角色的访问控制（RBAC）。此外，只能通过 RBAC 控制对无服务器缓存的访问。这适用于 Valkey 7.2 及更高版本和 Redis OSS 6.0 至 7.2。 RBAC 使您能够： + 通过用户组控制缓存访问。这些用户组旨在作为一种管理对缓存的访问权限的方式。 + 使用 *authN*，为每个用户设置密码，而非为每个集群设置身份验证令牌。 + 使用 *authZ*，拥有精细的用户权限。 + 以您的集群访问权限为基础 ACLs。 与 Valkey 和 Redis OSS AUTH（如果对客户端令牌进行身份验证，则所有经过身份验证的客户端都对缓存具有完全的访问权限）不同的是，RBAC 使您能够根据用户所需的角色将用户分配到不同的集合中。这些集合旨在作为一种管理对缓存的访问权限的方式。 通过 RBAC，您可以使用访问字符串创建用户并为其分配特定权限，如下所述。您可以将用户分配到与特定角色（管理员、人力资源）一致的集合，然后将其部署到一个或多个 ElastiCache 缓存中。这样，您就可以在使用相同 Valkey 或 Redis OSS 缓存的客户端之间建立安全边界，并阻止客户端彼此访问数据。 RBAC 设计用于支持在 Redis OSS 6 中引入的 [ACL](https://valkey.io/topics/acl/)。当你将 RBAC 与 ElastiCache Valkey 或 Redis OSS 缓存一起使用时，会有一些限制： + 为“VALKEY”引擎配置的用户组只能包含使用身份验证机制（密码或 IAM）的用户。这意味着所有使用“VALKEY”引擎的用户，以及任何其他使用“REDIS”引擎且设置配置为使用密码或 IAM 进行身份验证的用户，都可以属于此用户组。 + 在 Valkey 集群中使用 RBAC 时，使用“VALKEY”引擎和“REDIS”引擎的用户组均可使用。 + 在 Redis OSS 集群中使用 RBAC 时，只有使用“REDIS”引擎的用户组才能使用。 + 不能在访问字符串中指定密码。您可以通过[CreateUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateUser.html)或[ModifyUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyUser.html)呼叫来设置密码。 + 对于用户权利，您可以启用或禁用用户，将 `on` 和 `off` 作为访问字符串的一部分。如果两者在访问字符串中均未指定，则将为用户分配 `off` 并且用户没有访问缓存的权限。 + 您不能将 forbidden 和 renamed 命令作为访问字符串的一部分。如果您指定了已禁止的命令或重命名命令，则会引发异常。如果要对重命名的命令使用访问控制列表 (ACLs)，请指定该命令的原始名称，换言之，在重命名命令之前的名称。 + 您不能将 `reset` 命令作为访问字符串的一部分。你可以使用 API 参数指定密码， ElastiCache 对于 Valkey 和 Redis，OSS 管理密码。因此，您不能使用 `reset`，因为此命令会移除用户的所有密码。 + Redis OSS 6 引入了 [ACL LIST](https://valkey.io/commands/acl-list) 命令。此命令返回用户列表以及应用于每个用户的 ACL 规则。 ElastiCache 支持该`ACL LIST`命令，但不像 Redis OSS 那样支持密码哈希。使用 ElastiCache，您可以使用该[DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)操作来获取类似的信息，包括访问字符串中包含的规则。但是，[DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)无法检索用户密码。 + [Valkey 和 Redis OSS 支持的其他只读命令包括 [ACL WHOAMI、ACL](https://valkey.io/commands/acl-whoami) USERS 和 [ACL C](https://valkey.io/commands/acl-users) AT。 ElastiCache ](https://valkey.io/commands/acl-cat) ElastiCache 适用于 Valkey 和 Redis 的 OSS 不支持任何其他基于写入的 ACL 命令。 + 以下限制适用： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonElastiCache/latest/dg/Clusters.RBAC.html) **RBAC 与 Valkey** 在 Valkey 中使用基于角色的访问控制时，用户和用户组是使用“VALKEY”引擎类型创建的。建议这样做，因为默认情况下，与 Redis OSS 相比，结合使用 Valkey 与 RBAC 提供了更高的安全性。预调配和无服务器 Valkey 集群都支持 VALKEY 用户和用户组关联。 Valkey 访问控制的主要功能包括： + Valkey 用户仅限于 Valkey 用户组关联。 + Valkey 用户组可以包含 Valkey 用户以及受密码保护或启用了 IAM 身份验证的 Redis OSS 用户。 + Valkey 用户必须使用密码保护或 IAM 身份验证。 + VALKEY 用户组只能关联到 VALKEY 集群 + 没有默认用户要求。当 Valkey 用户组连接到集群时，默认用户要求会自动禁用。客户在使用 ACL LIST 命令时会看到默认用户已关闭。 以下是有关将 RBAC 与 Valkey 和 Redis OSS 搭配使用的 ElastiCache 更多信息。 **Topics** + [使用访问字符串指定权限](#Access-string) + [将 RBAC 应用于 Valkey 或 Redis OSS ElastiCache 的缓存](#rbac-using) + [从 AUTH 迁移到 RBAC](#Migrate-From-RBAC-to-Auth) + [从 RBAC 迁移到 AUTH](#Migrate-From-RBAC-to-AUTH-1) + [为用户自动轮换密码](User-Secrets-Manager.md) + [使用 IAM 进行身份验证](auth-iam.md) ## 使用访问字符串指定权限 要指定对 ElastiCache Valkey 或 Redis OSS 缓存的权限，您需要创建一个访问字符串并通过或将其分配给用户。AWS CLIAWS 管理控制台 根据定义，访问字符串是指应用于用户的、以空格分隔的规则列表。它们定义了用户可以执行的命令以及用户可以对其进行操作的密钥。要执行命令，用户必须有权访问正在执行的命令以及命令访问的所有密钥。规则从左到右累积应用，如果提供的字符串中存在冗余，则可以使用更简单的字符串代替提供的字符串。 有关 ACL 规则的语法的信息，请参阅 [ACL](https://valkey.io/topics/acl/)。 在以下示例中，访问字符串表示具有所有可用密钥和命令访问权限的活动用户。 `on ~* +@all` 访问字符串语法分解如下： + `on` – 用户是活动用户。 + `~*` – 具有对所有可用密钥的访问权限。 + `+@all` – 具有对所有可用命令的访问权限。 上述设置的限制性最小。您可以修改这些设置以使其更加安全。 在以下示例中，访问字符串表示一个用户，其访问权限限于对以“app::”键空间开头的键进行读取访问 `on ~app::* -@all +@read` 您可以通过列出用户有权访问的命令来进一步优化这些权限： `+command1` – 用户对命令的访问被限制为 *`command1`*。 `+@category` – 用户的访问被限制为某个类别的命令。 有关向用户分配访问字符串的信息，请参阅 [使用控制台和 CLI 创建用户和用户组](#Users-management)。 如果要将现有工作负载迁移到 ElastiCache，则可以通过调用来检索访问字符串`ACL LIST`，但不包括用户和任何密码哈希。 对于 Redis OSS 版本 6.2 及更高版本，还支持以下访问字符串语法： + `&*` – 具有对所有可用频道的访问权限。 对于 Redis OSS 版本 7.0 及更高版本，还支持以下访问字符串语法： + `|` - 可用于屏蔽子命令（例如 “-config\$1set”）。 + `%R~` - 添加指定的读取密钥模式。此行为与常规密钥模式类似，但仅授予读取与给定模式匹配的密钥的权限。有关更多信息，请参阅[密钥权限](https://valkey.io/topics/acl/)。 + `%W~` - 添加指定的写入密钥模式。此行为与常规密钥模式类似，但仅授予写入与给定模式匹配的密钥的权限。有关更多信息，请参阅 [ ACL 密钥权限](https://valkey.io/topics/acl/)。 + `%RW~` - `~` 的别名。 + `()` - 创建一个新的选择器作为匹配规则的依据。选择器在获得用户权限后进行评估，并根据其定义顺序进行评估。如果命令与用户权限或任何选择器匹配，则允许使用。有关更多信息，请参阅 [ACL selectors](https://valkey.io/topics/acl/)（ACL 选择器）。 + `clearselectors` - 删除附加到用户的所有选择器。 ## 将 RBAC 应用于 Valkey 或 Redis OSS ElastiCache 的缓存 要用 ElastiCache 于 Valkey 或 Redis OSS RBAC，请执行以下步骤： 1. 创建一个或多个用户。 1. 创建用户组并将用户添加到该组中。 1. 将用户组分配给已启用了传输中加密的缓存。 下方详细地说明了这些步骤。 **Topics** + [使用控制台和 CLI 创建用户和用户组](#Users-management) + [使用控制台和 CLI 管理用户组](#User-Groups) + [将用户组分配给无服务器缓存](#Users-groups-to-serverless-caches) + [将用户组分配给复制组](#Users-groups-to-RGs) ### 使用控制台和 CLI 创建用户和用户组 RBAC 用户的用户信息为用户 ID、用户名以及可选的密码和访问字符串。访问字符串提供对密钥和命令的权限级别。用户 ID 对于用户是唯一的，用户名则是传递给引擎的内容。 确保您提供的用户权限符合用户组的预期目的。例如，如果您创建一个名为 `Administrators` 的用户组，则添加到该组的任何用户都应将其访问字符串设置为对密钥和命令具有完全访问权限。对于 `e-commerce` 用户组中的用户，您可以将其访问字符串设置为只读访问。 ElastiCache 自动为默认用户配置用户 ID 和用户名`"default"`，并将其添加到所有用户组中。您无法修改或删除该用户。该用户旨在与以前 Redis OSS 版本的默认行为兼容，并具有一个访问字符串，允许它调用所有命令并访问所有密钥。 要向缓存添加适当的访问控制，请将此默认用户替换为未启用的或使用强密码的新用户。要更改默认用户，请创建一个新用户，其用户名设置为 `default`。然后，您可以用其替换原始默认用户。 以下过程演示了如何用另一个具有已修改访问字符串的 `default` 用户替换原始 `default` 用户。 **修改控制台上的默认用户** 1. 登录AWS 管理控制台并打开 Amazon ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。 1. 在导航窗格中，选择**用户组管理**。 1. 对于**用户组 ID**，选择要修改的 ID。确保选择的是链接，而不是复选框。 1. 选择**修改**。 1. 在**修改**窗口中，选择**管理**。对于“选择所需用户”，选择**用户名**为默认值的用户。 1. 选择**选择**。 1. 选择 **Modify**(修改)。执行此操作时，原始默认用户与缓存之间的任何现有连接将被终止。 **使用修改默认用户AWS CLI** 1. 使用以下命令，创建用户名为 `default` 的新用户。 对于 Linux、macOS 或 Unix： ``` aws elasticache create-user \ --user-id "new-default-user" \ --user-name "default" \ --engine "VALKEY" \ --passwords "a-str0ng-pa))word" \ --access-string "off +get ~keys*" ``` 对于 Windows： ``` aws elasticache create-user ^ --user-id "new-default-user" ^ --user-name "default" ^ --engine "VALKEY" ^ --passwords "a-str0ng-pa))word" ^ --access-string "off +get ~keys*" ``` 1. 创建用户组并添加先前创建的用户。 对于 Linux、macOS 或 Unix： ``` aws elasticache create-user-group \ --user-group-id "new-group-2" \ --engine "VALKEY" \ --user-ids "new-default-user" ``` 对于 Windows： ``` aws elasticache create-user-group ^ --user-group-id "new-group-2" ^ --engine "VALKEY" ^ --user-ids "new-default-user" ``` 创建用户时，最多可以设置两个密码。修改密码时，将保持与缓存之间的所有现有连接。 特别是，在 Valkey 和 Redis OSS 上使用 RBAC 时，请注意以下用户密码限制： ElastiCache + 密码必须是 16-128 个可打印字符。 + 不允许使用以下非字母数字字符：`,` `""` `/` `@`。 #### 使用控制台和 CLI 管理用户 使用以下过程在控制台上管理用户。 **在控制台上管理用户** 1. 登录AWS 管理控制台并打开 Amazon ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。 1. 在 Amazon ElastiCache 控制面板上，选择**用户管理**。有以下选项可用： + **创建用户** – 创建用户时，输入用户 ID、用户名、身份验证模式和访问字符串。访问字符串设置允许用户使用的密钥和命令的权限级别。 创建用户时，最多可以设置两个密码。修改密码时，将保持与缓存之间的所有现有连接。 + **修改用户** – 允许您更新用户的身份验证设置或更改其访问字符串。 + **删除用户** – 将账户从它所属的任何用户组中移除。 按以下过程使用AWS CLI管理用户。 **使用 CLI 修改用户** + 使用 `modify-user` 命令更新用户密码或者更改用户的访问权限。 修改用户后，将更新与该用户关联的用户组以及与该用户组关联的任何缓存。将会保持所有现有连接。示例如下。 对于 Linux、macOS 或 Unix： ``` aws elasticache modify-user \ --user-id user-id-1 \ --access-string "~objects:* ~items:* ~public:*" \ --authentication-mode Type=iam ``` 对于 Windows： ``` aws elasticache modify-user ^ --user-id user-id-1 ^ --access-string "~objects:* ~items:* ~public:*" ^ --authentication-mode Type=iam ``` **注意** 建议您不要使用 `nopass` 选项。如果您按此建议操作，我们建议将用户的权限设置为只读，且仅能访问一组有限的密钥。 **使用 CLI 删除用户** + 使用 `delete-user` 命令删除用户。此账户将被删除并从其所属的任何用户组中移除。示例如下： 对于 Linux、macOS 或 Unix： ``` aws elasticache delete-user \ --user-id user-id-2 ``` 对于 Windows： ``` aws elasticache delete-user ^ --user-id user-id-2 ``` 要查看用户列表，请调用 [describe-users](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-users.html) 操作。 ``` aws elasticache describe-users ``` ### 使用控制台和 CLI 管理用户组 您可以创建用户组来组织和控制用户对一个或多个缓存的访问权限，如下所示。 使用控制台通过以下过程管理用户组。 **使用控制台管理用户组** 1. 登录AWS 管理控制台并打开 Amazon ElastiCache 控制台，网址为[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。 1. 在 Amazon ElastiCache 控制面板上，选择**用户组管理**。 以下操作可用于创建新用户组： + **创建** – 创建用户组时，您可以添加用户，然后将用户组分配给缓存。例如，您可以为在缓存上具有管理角色的用户创建一个 `Admin` 用户组。 **重要** 如果您未使用 Valkey 或 Redis OSS 用户组，则在创建用户组时必须包含默认用户。 + **Add Users（添加用户）**– 向用户组添加用户。 + **Remove Users（移除用户）**– 从用户组中移除用户。当用户从用户组中移除时，他们与缓存之间的任何现有连接都将终止。 + **Delete（删除）**– 使用此操作删除用户组。请注意，将删除用户组本身，而不是属于该组的用户。 对于现有用户组，您可执行以下操作： + **Add User（添加用户）**– 将现有用户添加到用户组。 + **Delete Users（删除用户）**– 从用户组中移除现有用户。 **注意** 用户将从用户组中移除，但不会从系统中删除。 使用 CLI 通过以下过程管理用户组。 **使用 CLI 创建新用户组并添加用户** + 使用 `create-user-group` 命令，如下所示： 对于 Linux、macOS 或 Unix： ``` aws elasticache create-user-group \ --user-group-id "new-group-1" \ --engine "VALKEY" \ --user-ids user-id-1, user-id-2 ``` 对于 Windows： ``` aws elasticache create-user-group ^ --user-group-id "new-group-1" ^ --engine "VALKEY" ^ --user-ids user-id-1, user-id-2 ``` **使用 CLI 通过添加新用户或移除当前成员来修改用户组** + 使用 `modify-user-group` 命令，如下所示： 对于 Linux、macOS 或 Unix： ``` aws elasticache modify-user-group --user-group-id new-group-1 \ --user-ids-to-add user-id-3 \ --user-ids-to-remove user-id-2 ``` 对于 Windows： ``` aws elasticache modify-user-group --user-group-id new-group-1 ^ --user-ids-to-add user-id-3 ^ --user-ids-to-removere user-id-2 ``` **注意** 此命令将结束属于从用户组中移除的用户的任何打开的连接。 **使用 CLI 删除用户组** + 使用 `delete-user-group` 命令，如下所示：将删除用户组本身，而不是属于该组的用户。 对于 Linux、macOS 或 Unix： ``` aws elasticache delete-user-group / --user-group-id ``` 对于 Windows： ``` aws elasticache delete-user-group ^ --user-group-id ``` 要查看用户组列表，可以调用该[describe-user-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-user-groups.html)操作。 ``` aws elasticache describe-user-groups \ --user-group-id test-group ``` ### 将用户组分配给无服务器缓存 创建用户组并添加用户后，实施 RBAC 的最后步骤是将用户组分配给无服务器缓存。 #### 使用控制台将用户组分配给无服务器缓存 要使用向无服务器缓存中添加用户组AWS 管理控制台，请执行以下操作： + 对于已禁用集群模式，请参阅 [创建 Valkey（已禁用集群模式）集群（控制台）](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs) + 对于已启用集群模式，请参阅 [创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster) #### 使用将用户组分配给无服务器缓存AWS CLI 以下AWS CLI操作使用带值`my-user-group-id`的**user-group-id**参数创建无服务器缓存。用已存在的子网组替换子网组 `sng-test`。 **关键参数** + **--engine** – 必须为 `VALKEY` 或 `REDIS`。 + **--user-group-id** – 此值提供用户组的 ID，该用户组由对缓存具有指定访问权限的用户组成。 对于 Linux、macOS 或 Unix： ``` aws elasticache create-serverless-cache \ --serverless-cache-name "new-serverless-cache" \ --description "new-serverless-cache" \ --engine "VALKEY" \ --user-group-id "new-group-1" ``` 对于 Windows： ``` aws elasticache create-serverless-cache ^ --serverless-cache-name "new-serverless-cache" ^ --description "new-serverless-cache" ^ --engine "VALKEY" ^ --user-group-id "new-group-1" ``` 以下AWS CLI操作使用带值的**user-group-id**参数修改无服务器缓存。`my-user-group-id` 对于 Linux、macOS 或 Unix： ``` aws elasticache modify-serverless-cache \ --serverless-cache-name serverless-cache-1 \ --user-group-id "new-group-2" ``` 对于 Windows： ``` aws elasticache modify-serverless-cache ^ --serverless-cache-name serverless-cache-1 ^ --user-group-id "new-group-2" ``` 请注意，对缓存所做的任何修改都将异步更新。您可通过查看事件来监控进度。有关更多信息，请参阅 [查看 ElastiCache 事件](ECEvents.Viewing.md)。 ### 将用户组分配给复制组 创建用户组并添加用户后，实施 RBAC 的最后步骤是将用户组分配给复制组。 #### 使用控制台将用户组分配给复制组 要使用向复制中添加用户组AWS 管理控制台，请执行以下操作： + 对于已禁用集群模式，请参阅 [创建 Valkey（已禁用集群模式）集群（控制台）](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs) + 对于已启用集群模式，请参阅 [创建 Valkey 或 Redis OSS（已启用集群模式）集群（控制台）](Clusters.Create.md#Clusters.Create.CON.RedisCluster) #### 使用将用户组分配给复制组AWS CLI 以下AWS CLI操作创建一个启用传输中加密 (TLS) 且**user-group-ids**参数值为的复制组`my-user-group-id`。用已存在的子网组替换子网组 `sng-test`。 **关键参数** + **--engine** – 必须为 `valkey` 或 `redis`。 + **--engine-version** – 必须是 6.0 或更高版本。 + **--transit-encryption-enabled** – 必需，用于身份验证和关联用户组。 + **--user-group-ids** – 此值提供用户组的 ID，该用户组由对缓存具有指定访问权限的用户组成。 + **--cache-subnet-group** – 必需，用于关联用户组。 对于 Linux、macOS 或 Unix： ``` aws elasticache create-replication-group \ --replication-group-id "new-replication-group" \ --replication-group-description "new-replication-group" \ --engine "VALKEY" \ --cache-node-type cache.m5.large \ --transit-encryption-enabled \ --user-group-ids "new-group-1" \ --cache-subnet-group "cache-subnet-group" ``` 对于 Windows： ``` aws elasticache create-replication-group ^ --replication-group-id "new-replication-group" ^ --replication-group-description "new-replication-group" ^ --engine "VALKEY" ^ --cache-node-type cache.m5.large ^ --transit-encryption-enabled ^ --user-group-ids "new-group-1" ^ --cache-subnet-group "cache-subnet-group" ``` 以下AWS CLI操作修改启用了传输中加密 (TLS) 的复制组以及带有值`my-user-group-id`的**user-group-ids**参数。 对于 Linux、macOS 或 Unix： ``` aws elasticache modify-replication-group \ --replication-group-id replication-group-1 \ --user-group-ids-to-remove "new-group-1" \ --user-group-ids-to-add "new-group-2" ``` 对于 Windows： ``` aws elasticache modify-replication-group ^ --replication-group-id replication-group-1 ^ --user-group-ids-to-remove "new-group-1" ^ --user-group-ids-to-add "new-group-2" ``` 记下响应中的 `PendingChanges`。对缓存所做的任何修改都将异步更新。您可通过查看事件来监控进度。有关更多信息，请参阅 [查看 ElastiCache 事件](ECEvents.Viewing.md)。 ## 从 AUTH 迁移到 RBAC 如果您正在使用 [使用 Valkey 和 Redis OSS AUTH 命令进行身份验证](auth.md) 中所述的 AUTH，并希望迁移到使用 RBAC，请使用以下过程。 使用控制台通过以下过程从 AUTH 迁移到 RBAC。 **使用控制台从 Valkey 或 Redis OSS AUTH 迁移到 RBAC** 1. 登录AWS 管理控制台并打开 ElastiCache 控制台，网址为[ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。 1. 从右上角的列表中，选择要修改的缓存所在的AWS区域。 1. 在导航窗格中，选择在要修改的缓存上运行的引擎。 此时会显示选定引擎的缓存列表。 1. 在缓存列表中，对于要修改的缓存，选择其名称。 1. 对于 **Actions**（操作），选择 **Modify**（修改）。 此时将显示**修改**窗口。 1. 对于**访问控制**，选择**用户组访问控制列表**。 1. 对于**用户组访问控制列表**，选择一个用户组。 1. 选择**预览更改**，然后在下一个屏幕上选择**修改**。 使用 CLI 通过以下过程从 Valkey 或 Redis OSS AUTH 迁移到 RBAC。 **使用 CLI 从 AUTH 迁移到 RBAC** + 使用 `modify-replication-group` 命令，如下所示： 对于 Linux、macOS 或 Unix： ``` aws elasticache modify-replication-group --replication-group-id test \ --auth-token-update-strategy DELETE \ --user-group-ids-to-add user-group-1 ``` 对于 Windows： ``` aws elasticache modify-replication-group --replication-group-id test ^ --auth-token-update-strategy DELETE ^ --user-group-ids-to-add user-group-1 ``` ## 从 RBAC 迁移到 AUTH 如果您正在使用 RBAC 并希望迁移到 Redis OSS AUTH，请参阅[从 RBAC 迁移到 AUTH](auth.md#Migrate-From-RBAC-to-AUTH)。 **注意** 如果您需要禁用 ElastiCache 缓存的访问控制，则需要通过AWS CLI。有关更多信息，请参阅 [在 ElastiCache Valkey 或 Redis OSS 缓存上禁用访问控制](in-transit-encryption-disable.md)。 # 为用户自动轮换密码 使用AWS Secrets Manager，您可以将代码中的硬编码凭据（包括密码）替换为对 Secrets Manager 的 API 调用，以编程方式检索密钥。这有助于确保检查您的代码的人不会泄露密钥，因为其中根本不包含密钥。此外，您还可以配置 Secrets Manager 以根据指定的计划自动轮换密钥。这使您能够将长期密钥替换为短期密钥，这有助于显著减少泄露风险。 使用 Secrets Manager，你可以使用 ElastiCache Secrets Manager 提供的AWS Lambda功能自动轮换 Redis OSS 密码（即机密）。 有关的更多信息AWS Secrets Manager，请参阅[什么是AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) ## 如何 ElastiCache 使用秘密 Valkey 7.2 及更高版本具有与 Redis OSS 7.0 相同的功能集。在 Redis OSS 6 中， ElastiCache 引入该集群是[基于角色的访问控制（RBAC）](Clusters.RBAC.md)为了保护 Valkey 或 Redis OSS 集群而引入的。此功能允许在可以执行的命令和可以访问的密钥方面限制某些连接。使用 RBAC，当客户使用密码创建用户时，密码值需要以明文形式手动输入，且对操作员可见。 使用 Secrets Manager，应用程序从 Secrets Manager 获取密码，而不是手动输入密码并将其存储在应用程序的配置中。有关如何执行此操作的信息，请参阅 [ElastiCache 用户如何与密钥关联](#How-User-Secrets-Manager-Associate)。 使用密钥会产生费用。有关定价信息，请参阅 [AWS Secrets Manager 定价](https://aws.amazon.com/secrets-manager/pricing/)。 ## ElastiCache 用户如何与密钥关联 Secrets Manager 将在密钥的 `SecretString` 字段中为关联用户保留引用。 ElastiCache 侧面不会提及秘密。 ``` { "password": "strongpassword", "username": "user1", "user_arn": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1" //this is the bond between the secret and the user } ``` ## Lambda 轮换函数 要启用 Secrets Manager 自动密码轮换，您需要创建一个 Lambda 函数，该函数将与 [modify-user](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-user.html) API 交互以更新用户的密码。 有关其工作原理的信息，请参阅[轮换的工作原理](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html#rotate-secrets_how)。 **注意** 对于某些AWS服务，为了避免混淆副手的情况，AWS建议您同时使用`aws:SourceArn`和`aws:SourceAccount`全局条件键。但如果轮换函数策略中包括 `aws:SourceArn` 条件，则轮换函数只能用于轮换该 ARN 指定的密钥。我们建议您仅在其中包括上下文键 `aws:SourceAccount`，以便对多个密钥使用轮换函数。 有关你可能遇到的任何问题，请参阅 S [AWS ecrets Manager 轮换疑难解答](https://docs.aws.amazon.com/secretsmanager/latest/userguide/troubleshoot_rotation.html)。 ## 如何创建 ElastiCache 用户并将其与 Secrets Manager 关联 以下步骤说明如何创建用户并将其与 Secrets Manager 关联： 1. **创建不活跃的用户** 对于 Linux、macOS 或 Unix： ``` aws elasticache create-user \ --user-id user1 \ --user-name user1 \ --engine "REDIS" \ --no-password \ // no authentication is required --access-string "*off* +get ~keys*" // this disables the user ``` 对于 Windows： ``` aws elasticache create-user ^ --user-id user1 ^ --user-name user1 ^ --engine "REDIS" ^ --no-password ^ // no authentication is required --access-string "*off* +get ~keys*" // this disables the user ``` 您看到的响应与以下内容类似： ``` { "UserId": "user1", "UserName": "user1", "Status": "active", "Engine": "redis", "AccessString": "off ~keys* -@all +get", "UserGroupIds": [], "Authentication": { "Type": "no_password" }, "ARN": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1" } ``` 1. **创建密钥** 对于 Linux、macOS 或 Unix： ``` aws secretsmanager create-secret \ --name production/ec/user1 \ --secret-string \ '{ "user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1", "username":"user1" }' ``` 对于 Windows： ``` aws secretsmanager create-secret ^ --name production/ec/user1 ^ --secret-string ^ '{ "user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1", "username":"user1" }' ``` 您看到的响应与以下内容类似： ``` { "ARN": "arn:aws:secretsmanager:us-east-1:123456xxxx:secret:production/ec/user1-eaFois", "Name": "production/ec/user1", "VersionId": "aae5b963-1e6b-4250-91c6-ebd6c47d0d95" } ``` 1. **配置 Lambda 函数来轮换您的密码** 1. 登录AWS 管理控制台并打开 Lambda 控制台，网址为 [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/elasticache/) 1. 在导航面板上，选择 **Functions**（函数），然后选择您创建的函数。选择函数名称，而不是其左边的复选框。 1. 选择**配置**选项卡。 1. 在 **General configuration**（常规配置）中，选择 **Edit**（编辑），然后将 **Timeout**（超时）设置为至少 12 分钟。 1. 选择**保存**。 1. 选择 **Environment variables**（环境变量），然后设置以下内容： 1. SECRETS\$1MANAGER\$1ENDPOINT – https://secretsmanager.**REGION**.amazonaws.com 1. SECRET\$1ARN – 您在第 2 步中创建的密钥的 Amazon 资源名称（ARN）。 1. 用户名-用户的用户名， ElastiCache 1. 选择**保存**。 1. 选择 **Permissions**（权限）。 1. 在 **Execution role**（执行角色）下，选择要在 IAM 控制台上查看的 Lambda 函数角色的名称。 1. Lambda 函数需要以下权限才能修改用户和设置密码： ElastiCache ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "elasticache:DescribeUsers", "elasticache:ModifyUser" ], "Resource": "arn:aws:elasticache:us-east-1:123456789012:user:user1" } ] } ``` ------ Secrets Manager ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "secretsmanager:GetSecretValue", "secretsmanager:DescribeSecret", "secretsmanager:PutSecretValue", "secretsmanager:UpdateSecretVersionStage" ], "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:XXXX" }, { "Effect": "Allow", "Action": "secretsmanager:GetRandomPassword", "Resource": "*" } ] } ``` ------ 1. 设置 Secrets Manager 密钥轮换 1. **使用AWS 管理控制台，请参阅使用[控制台设置 Secrets Manager AWS密钥的自动轮换](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_turn-on-for-other.html)** 有关设置轮换计划的更多信息，请参阅 [Secrets Manager 轮换中的计划表达式](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_schedule.html)。 1. **使用AWS CLI，请参阅[设置自动旋转以AWS Secrets Manager使用AWS Command Line Interface](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets-cli.html)** # 使用 IAM 进行身份验证 **Topics** + [概述](#auth-iam-overview) + [限制](#auth-iam-limits) + [设置](#auth-iam-setup) + [连接](#auth-iam-Connecting) ## 概述 使用 IAM 身份验证，当您的缓存配置 ElastiCache 为使用 Valkey 或 Redis OSS 版本 7 或更高版本时，您可以使用AWS IAM 身份验证与 Valkey 或 Redis OSS 的连接。这使您可以增强安全模型并简化许多管理安全任务。您还可以使用 IAM 身份验证按照最低权限原则为每个 ElastiCache 缓存和 ElastiCache 用户配置精细的访问控制。IAM 身份验证 ElastiCache 的工作原理是在 Valkey 或 Redis OSS 或命令中提供短期的 IAM 身份验证令牌，而不是长期存在的 ElastiCache 用户密码。`AUTH` `HELLO`有关 IAM 身份验证令牌的更多信息，请参阅《AWS通用参考指南》中的[签名版本 4 签名流程](https://docs.aws.amazon.com//general/latest/gr/signature-version-4.html)和下面的代码示例。 您可以使用 IAM 身份及其关联策略进一步限制 Valkey 或 Redis OSS 访问权限。您还可以直接从联合身份提供商向用户授予对 Valkey 或 Redis OSS 缓存的访问权限。 要AWS将 IAM 与配合使用 ElastiCache，您首先需要创建一个身份验证模式设置为 IAM 的 ElastiCache 用户。然后，您可以创建或重复使用 IAM 身份。IAM 身份需要关联策略才能将`elasticache:Connect`操作授予 ElastiCache 缓存和 ElastiCache 用户。配置完成后，您可以使用 IAM 用户或角色的AWS证书创建 IAM 身份验证令牌。最后，在连接到您的缓存时，您需要在 Valkey 或 Redis OSS 客户端中提供有效期较短的 IAM 身份验证令牌作为密码。支持凭证提供程序的 Valkey 或 Redis OSS 客户端可以自动为每个新连接生成临时证书。 ElastiCache 将对启用 IAM 的 ElastiCache 用户的连接请求执行 IAM 身份验证，并将通过 IAM 验证连接请求。 ## 限制 使用 IAM 身份验证时，以下限制适用： + 用 ElastiCache 于 Valkey 7.2 及以上版本或 Redis OSS 7.0 及以上版本时，IAM 身份验证可用。 + 对于启用 IAM 的 ElastiCache 用户，用户名和用户 ID 属性必须相同。 + IAM 身份验证令牌的有效期为 15 分钟。对于长时间的连接，建议使用支持凭证提供程序接口的 Valkey 或 Redis OSS 客户端。 + 通过 IAM 身份验证的 Valkey 或 Redis OSS 连接将在 12 小时后自动断开。 ElastiCache 通过使用新 IAM 身份验证令牌发送 `AUTH` 或 `HELLO` 命令，可以将连接延长 12 小时。 + `MULTI EXEC` 命令不支持 IAM 身份验证。 + 目前，IAM 身份验证支持以下全局条件上下文键： + 对无服务器缓存使用 IAM 身份验证时，支持 `aws:VpcSourceIp`、`aws:SourceVpc`、`aws:SourceVpce`、`aws:CurrentTime`、`aws:EpochTime` 和 `aws:ResourceTag/%s`（从关联的无服务器缓存和用户）。 + 对复制组使用 IAM 身份验证时，支持 `aws:SourceIp` 和 `aws:ResourceTag/%s`（从关联的复制组和用户）。 有关全局条件上下文键的更多信息，请参阅《IAM 用户指南》中的 [AWS全局条件上下文键](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)。 ## 设置 要设置 IAM 身份验证，请执行以下操作： 1. 创建缓存 ``` aws elasticache create-serverless-cache \ --serverless-cache-name cache-01 \ --description "ElastiCache IAM auth application" \ --engine redis ``` 1. 为您的角色创建 IAM 信任政策文档，如下所示，允许您的账户承担新角色。将策略保存到名为 *trust-policy.json* 的文件中。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::123456789012:root" }, "Action": "sts:AssumeRole" } } ``` ------ 1. 创建 IAM 策略文档，如下所示。将策略保存到名为 *policy.json* 的文件中。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect" : "Allow", "Action" : [ "elasticache:Connect" ], "Resource" : [ "arn:aws:elasticache:us-east-1:123456789012:serverlesscache:cache-01", "arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01" ] } ] } ``` ------ 1. 创建 IAM 角色。 ``` aws iam create-role \ --role-name "elasticache-iam-auth-app" \ --assume-role-policy-document file://trust-policy.json ``` 1. 创建 IAM 策略。 ``` aws iam create-policy \ --policy-name "elasticache-allow-all" \ --policy-document file://policy.json ``` 1. 向角色附加 IAM 策略。 ``` aws iam attach-role-policy \ --role-name "elasticache-iam-auth-app" \ --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all" ``` 1. 创建启用 IAM 的新用户。 ``` aws elasticache create-user \ --user-name iam-user-01 \ --user-id iam-user-01 \ --authentication-mode Type=iam \ --engine redis \ --access-string "on ~* +@all" ``` 1. 创建用户组并附加用户。 ``` aws elasticache create-user-group \ --user-group-id iam-user-group-01 \ --engine redis \ --user-ids default iam-user-01 aws elasticache modify-serverless-cache \ --serverless-cache-name cache-01 \ --user-group-id iam-user-group-01 ``` ## 连接 **使用令牌作为密码进行连接** 您首先需要使用 [AWS SigV4 预签名请求](https://docs.aws.amazon.com//general/latest/gr/sigv4-signed-request-examples.html)生成有效期较短的 IAM 身份验证令牌。之后，您需要在连接到 Valkey 或 Redis OSS 缓存时提供 IAM 身份验证令牌作为密码，如下例所示。 ``` String userId = "insert user id"; String cacheName = "insert cache name"; boolean isServerless = true; String region = "insert region"; // Create a default AWS Credentials provider. // This will look for AWS credentials defined in environment variables or system properties. AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain(); // Create an IAM authentication token request and signed it using the AWS credentials. // The pre-signed request URL is used as an IAM authentication token for ElastiCache with Redis OSS. IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless); String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials()); // Construct Redis OSS URL with IAM Auth credentials provider RedisURI redisURI = RedisURI.builder() .withHost(host) .withPort(port) .withSsl(ssl) .withAuthentication(userId, iamAuthToken) .build(); // Create a new Lettuce Redis OSS client RedisClient client = RedisClient.create(redisURI); client.connect(); ``` 以下为 `IAMAuthTokenRequest` 的定义。 ``` public class IAMAuthTokenRequest { private static final HttpMethodName REQUEST_METHOD = HttpMethodName.GET; private static final String REQUEST_PROTOCOL = "http://"; private static final String PARAM_ACTION = "Action"; private static final String PARAM_USER = "User"; private static final String PARAM_RESOURCE_TYPE = "ResourceType"; private static final String RESOURCE_TYPE_SERVERLESS_CACHE = "ServerlessCache"; private static final String ACTION_NAME = "connect"; private static final String SERVICE_NAME = "elasticache"; private static final long TOKEN_EXPIRY_SECONDS = 900; private final String userId; private final String cacheName; private final String region; private final boolean isServerless; public IAMAuthTokenRequest(String userId, String cacheName, String region, boolean isServerless) { this.userId = userId; this.cacheName = cacheName; this.region = region; this.isServerless = isServerless; } public String toSignedRequestUri(AWSCredentials credentials) throws URISyntaxException { Request request = getSignableRequest(); sign(request, credentials); return new URIBuilder(request.getEndpoint()) .addParameters(toNamedValuePair(request.getParameters())) .build() .toString() .replace(REQUEST_PROTOCOL, ""); } private Request getSignableRequest() { Request request = new DefaultRequest<>(SERVICE_NAME); request.setHttpMethod(REQUEST_METHOD); request.setEndpoint(getRequestUri()); request.addParameters(PARAM_ACTION, Collections.singletonList(ACTION_NAME)); request.addParameters(PARAM_USER, Collections.singletonList(userId)); if (isServerless) { request.addParameters(PARAM_RESOURCE_TYPE, Collections.singletonList(RESOURCE_TYPE_SERVERLESS_CACHE)); } return request; } private URI getRequestUri() { return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, cacheName)); } private void sign(SignableRequest request, AWSCredentials credentials) { AWS4Signer signer = new AWS4Signer(); signer.setRegionName(region); signer.setServiceName(SERVICE_NAME); DateTime dateTime = DateTime.now(); dateTime = dateTime.plus(Duration.standardSeconds(TOKEN_EXPIRY_SECONDS)); signer.presignRequest(request, credentials, dateTime.toDate()); } private static List toNamedValuePair(Map> in) { return in.entrySet().stream() .map(e -> new BasicNameValuePair(e.getKey(), e.getValue().get(0))) .collect(Collectors.toList()); } } ``` **使用凭证提供程序进行连接** 以下代码显示了如何 ElastiCache 使用 IAM 身份验证凭证提供商进行身份验证。 ``` String userId = "insert user id"; String cacheName = "insert cache name"; boolean isServerless = true; String region = "insert region"; // Create a default AWS Credentials provider. // This will look for AWS credentials defined in environment variables or system properties. AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain(); // Create an IAM authentication token request. Once this request is signed it can be used as an // IAM authentication token for ElastiCache with Redis OSS. IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless); // Create a Redis OSS credentials provider using IAM credentials. RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider( userId, iamAuthTokenRequest, awsCredentialsProvider); // Construct Redis OSS URL with IAM Auth credentials provider RedisURI redisURI = RedisURI.builder() .withHost(host) .withPort(port) .withSsl(ssl) .withAuthentication(redisCredentialsProvider) .build(); // Create a new Lettuce Redis OSS client RedisClient client = RedisClient.create(redisURI); client.connect(); ``` 以下是 Lettuce Redis OSS 客户端的示例，该客户端将封装在凭证提供程序 IAMAuthTokenRequest 中，以便在需要时自动生成临时证书。 ``` public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider { private static final long TOKEN_EXPIRY_SECONDS = 900; private final AWSCredentialsProvider awsCredentialsProvider; private final String userId; private final IAMAuthTokenRequest iamAuthTokenRequest; private final Supplier iamAuthTokenSupplier; public RedisIAMAuthCredentialsProvider(String userId, IAMAuthTokenRequest iamAuthTokenRequest, AWSCredentialsProvider awsCredentialsProvider) { this.userName = userName; this.awsCredentialsProvider = awsCredentialsProvider; this.iamAuthTokenRequest = iamAuthTokenRequest; this.iamAuthTokenSupplier = Suppliers.memoizeWithExpiration(this::getIamAuthToken, TOKEN_EXPIRY_SECONDS, TimeUnit.SECONDS); } @Override public Mono resolveCredentials() { return Mono.just(RedisCredentials.just(userId, iamAuthTokenSupplier.get())); } private String getIamAuthToken() { return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials()); } } ``` # 使用 Valkey 和 Redis OSS AUTH 命令进行身份验证 **注意** **AUTH** 已被 [基于角色的访问控制（RBAC）](Clusters.RBAC.md) 取代。所有无服务器缓存都必须使用 RBAC 进行身份验证。 通过使用 Valkey 和 Redis OSS 身份验证令牌（或密码），Valkey 和 Redis OSS 可以在允许客户端运行命令之前要求提供密码，从而提高数据安全性。**AUTH** 仅适用于基于节点的集群。 **Topics** + [Valkey 和 Redis ElastiCache OSS 的身份验证概述](#auth-overview) + [对适用 ElastiCache 于 Valkey 和 Redis 的 OSS 集群进行身份验证](#auth-using) + [修改现有集群上的 AUTH 令牌](#auth-modifyng-token) + [从 RBAC 迁移到 AUTH](#Migrate-From-RBAC-to-AUTH) ## Valkey 和 Redis ElastiCache OSS 的身份验证概述 当你在 for **AUTH** Valkey 和 Redis OSS 集群中使用时，会有一些改进。 ElastiCache 使用 AUTH 时，尤其要注意以下 AUTH 令牌或密码限制： + 令牌（或密码）必须是 16-128 个可打印字符。 + 非字母数字字符仅限使用 \$1、&、\$1、\$1、^、<、>、-。 + 只能为启用了传输中加密的 Valkey 或 Redis OSS 集群启用 AUTH。 要设置增强令牌，我们建议您遵循严格的密码策略，例如，要求满足以下条件： + 令牌（或密码）必须包含至少以下任意三种字符类型： + 大写字符 + 小写字符 + 数字 + 非字母数字字符（`!`、`&`、`#`、`$`、`^`、`<`、`>`、`-`） + 令牌（或密码）不能包含词典单词或稍加修改的词典单词。 + 令牌（或密码）不能与最近使用过的令牌相同或相似。 ## 对适用 ElastiCache 于 Valkey 和 Redis 的 OSS 集群进行身份验证 您可以要求用户在受令牌保护的 Valkey 或 Redis OSS 服务器上输入令牌（密码）。为此，在创建复制组或集群时，请在 `--auth-token` 参数（API：`AuthToken`）中包含正确的令牌。还要在复制组或集群的所有后续命令中包含该令牌。 以下AWS CLI操作创建启用了传输中加密 (TLS) 和**AUTH**令牌的复制组`This-is-a-sample-token`。用已存在的子网组替换子网组 `sng-test`。 **关键参数** + **--engine** – 必须为 `valkey` 或 `redis`。 + **--engine-version** – 如果引擎为 Redis OSS，则必须为 3.2.6、4.0.10 或更高版本。 + **--transit-encryption-enabled** – 对于身份验证和 HIPAA 资格是必需的。 + **--auth-token** – 对于 HIPAA 资格是必需的。该值必须是该受令牌保护的 Valkey 或 Redis OSS 服务器的正确令牌。 + **--cache-subnet-group** – 对于 HIPAA 资格是必需的。 对于 Linux、macOS 或 Unix： ``` aws elasticache create-replication-group \ --replication-group-id authtestgroup \ --replication-group-description authtest \ --engine redis \ --cache-node-type cache.m4.large \ --num-node-groups 1 \ --replicas-per-node-group 2 \ --transit-encryption-enabled \ --auth-token This-is-a-sample-token \ --cache-subnet-group sng-test ``` 对于 Windows： ``` aws elasticache create-replication-group ^ --replication-group-id authtestgroup ^ --replication-group-description authtest ^ --engine redis ^ --cache-node-type cache.m4.large ^ --num-node-groups 1 ^ --replicas-per-node-group 2 ^ --transit-encryption-enabled ^ --auth-token This-is-a-sample-token ^ --cache-subnet-group sng-test ``` ## 修改现有集群上的 AUTH 令牌 为了简化更新身份验证的过程，您可以修改集群上使用的 **AUTH** 令牌。如果引擎版本为 Valkey 7.2 或更高版本或 Redis 5.0.6 或更高版本，则可以进行此修改。 ElastiCache 还必须启用传输中加密。 修改 AUTH 令牌支持两种策略：ROTATE 和 SET。ROTATE 策略会向服务器添加一个额外的 AUTH 令牌，同时保留之前的令牌。SET 策略会更新服务器，使其仅支持一个 AUTH 令牌。请使用 `--apply-immediately` 参数进行这些修改调用以立即应用更改。 ### 轮换 AUTH 令牌 要使用新的 **AUTH 令牌**更新 Valkey 或 Redis OSS 服务器，请调用 `ModifyReplicationGroup` API，并将 `--auth-token` 参数设置为新的 **AUTH** 令牌，将 `--auth-token-update-strategy` 值设置为 ROTATE。ROTATE 修改完成后，除 `auth-token` 参数中指定的 AUTH 令牌外，集群还将支持之前的 AUTH 令牌。如果在 AUTH 令牌轮换之前未在复制组上配置 AUTH 令牌，则集群除了支持未进行身份验证的连接以外，还支持 `--auth-token` 参数中指定的 AUTH 令牌。请参阅[设置 AUTH 令牌](#auth-modifying-set)，使用更新策略 SET 更新所需的 AUTH 令牌。 **注意** 如果您之前未配置 AUTH 令牌，则修改完成后，除在 auth-token 参数中指定的一个令牌外，集群将不支持任何 AUTH 令牌。 如果在已支持两个 AUTH 令牌的服务器上执行此修改，则在此操作过程中还将删除最早的 AUTH 令牌。这允许服务器在给定时间内支持最多两个最新的 AUTH 令牌。 此时，您可以更新客户端以使用最新的 AUTH 令牌。在更新客户端后，您可以使用 SET 策略轮换 **AUTH** 令牌（在下一节中说明）以开始使用唯一的新令牌。 以下AWS CLI操作修改复制组以轮换令**AUTH**牌`This-is-the-rotated-token`。 对于 Linux、macOS 或 Unix： ``` aws elasticache modify-replication-group \ --replication-group-id authtestgroup \ --auth-token This-is-the-rotated-token \ --auth-token-update-strategy ROTATE \ --apply-immediately ``` 对于 Windows： ``` aws elasticache modify-replication-group ^ --replication-group-id authtestgroup ^ --auth-token This-is-the-rotated-token ^ --auth-token-update-strategy ROTATE ^ --apply-immediately ``` ### 设置 AUTH 令牌 要更新 Valkey 或 Redis OSS 服务器以支持单个所需 **AUTH** 令牌，请调用 `ModifyReplicationGroup` API 操作，并使用与上一个 AUTH 令牌值相同的 `--auth-token` 参数和 `SET` 值的 `--auth-token-update-strategy` 参数。SET 策略只能用于拥有 2 个 AUTH 令牌或之前使用 ROTATE 策略时拥有 1 个可选 AUTH 令牌的集群。在修改完成后，服务器仅支持 auth-token 参数中指定的 AUTH 令牌。 以下AWS CLI操作修改复制组以将 AUTH 令牌设置为。`This-is-the-set-token` 对于 Linux、macOS 或 Unix： ``` aws elasticache modify-replication-group \ --replication-group-id authtestgroup \ --auth-token This-is-the-set-token \ --auth-token-update-strategy SET \ --apply-immediately ``` 对于 Windows： ``` aws elasticache modify-replication-group ^ --replication-group-id authtestgroup ^ --auth-token This-is-the-set-token ^ --auth-token-update-strategy SET ^ --apply-immediately ``` ### 在现有集群上启用身份验证 要在现有 Valkey 或 Redis OSS 服务器上启用身份验证，请调用 `ModifyReplicationGroup` API 操作。调用 `ModifyReplicationGroup`，将 `--auth-token` 参数作为新令牌，并将 `--auth-token-update-strategy` 参数值设置为 ROTATE。 在 ROTATE 修改完成后，集群除了支持未进行身份验证的连接外，还支持 `--auth-token` 参数中指定的 **AUTH** 令牌。在所有客户端应用程序都更新为使用 AUTH 令牌针对 Valkey 或 Redis OSS 进行身份验证后，请使用 SET 策略根据需要标记 AUTH 令牌。只有启用了传输中加密（TLS）的 Valkey 和 Redis OSS 服务器才支持启用身份验证。 ## 从 RBAC 迁移到 AUTH 如果您使用 Valkey 或 Redis OSS 基于角色的访问控制（RBAC）对用户进行身份验证（如[基于角色的访问控制（RBAC）](Clusters.RBAC.md)中所述），并希望迁移到 AUTH，请使用以下流程。您可以使用控制台或 CLI 进行迁移。 **要使用控制台从 RBAC 迁移到 AUTH** 1. 登录AWS 管理控制台并打开 ElastiCache 控制台，网址为[ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)。 1. 从右上角的列表中，选择要修改的集群所在的AWS区域。 1. 在导航窗格中，选择在您要修改的集群上运行的引擎。 此时会显示选定引擎的集群列表。 1. 在集群列表中，对于要修改的集群，选择其名称。 1. 对于 **Actions**（操作），选择 **Modify**（修改）。 此时将显示**修改**窗口。 1. 对于**访问控制**，选择 **Valkey AUTH 默认用户访问**或 **Redis OSS AUTH 默认用户访问**。 1. 在 **Valkey AUTH 令牌**或 **Redis OSS AUTH 令牌**下，设置新令牌。 1. 选择**预览更改**，然后在下一个屏幕上选择**修改**。 **要从 RBAC 迁移到 AUTH，请使用AWS CLI** 使用以下任一命令为 Valkey 或 Redis OSS 复制组配置新的可选 **AUTH** 令牌。请注意，在使用下一步中的更新策略 `SET` 根据需要标记 Auth 令牌之前，可选的 Auth 令牌将允许对复制组进行未经身份验证的访问。 对于 Linux、macOS 或 Unix： ``` aws elasticache modify-replication-group \ --replication-group-id test \ --remove-user-groups \ --auth-token This-is-a-sample-token \ --auth-token-update-strategy ROTATE \ --apply-immediately ``` 对于 Windows： ``` aws elasticache modify-replication-group ^ --replication-group-id test ^ --remove-user-groups ^ --auth-token This-is-a-sample-token ^ --auth-token-update-strategy ROTATE ^ --apply-immediately ``` 执行上述命令后，您可以使用新配置的可选身份验证令牌更新您的 Valkey 或 Redis OSS 应用程序，以向 ElastiCache 复制组进行身份验证。要完成 Auth 令牌轮换，请在下面的后续命令中使用更新策略 `SET`。这将根据需要标记可选 AUTH 令牌。Auth 令牌更新完成后，复制组状态将显示为 `ACTIVE`，并且该复制组的所有连接都需要进行身份验证。 对于 Linux、macOS 或 Unix： ``` aws elasticache modify-replication-group \ --replication-group-id test \ --auth-token This-is-a-sample-token \ --auth-token-update-strategy SET \ --apply-immediately ``` 对于 Windows： ``` aws elasticache modify-replication-group ^ --replication-group-id test ^ --remove-user-groups ^ --auth-token This-is-a-sample-token ^ --auth-token-update-strategy SET ^ --apply-immediately ``` 有关更多信息，请参阅 [使用 Valkey 和 Redis OSS AUTH 命令进行身份验证](#auth)。 **注意** 如果您需要在 ElastiCache 集群上禁用访问控制，请参阅[在 ElastiCache Valkey 或 Redis OSS 缓存上禁用访问控制](in-transit-encryption-disable.md)。 # 在 ElastiCache Valkey 或 Redis OSS 缓存上禁用访问控制 按照以下说明操作，在 Valkey 或 Redis OSS 支持 TLS 的缓存上禁用访问控制。您的缓存将采用两种不同类型的配置之一：AUTH 默认用户访问权限或用户组访问控制（RBAC）列表。如果您的缓存在创建时使用 AUTH 配置，则必须先将其更改为 RBAC 配置，然后才能通过删除用户组来禁用缓存访问控制。如果您的缓存在创建时使用了 RBAC 配置，则可以直接将其禁用。 **禁用使用 RBAC 配置的 Valkey 或 Redis OSS 无服务器缓存** 1. 删除用户组以禁用访问控制。 ``` aws elasticache modify-serverless-cache --serverless-cache-name --remove-user-group ``` 1. （可选）验证没有用户组与无服务器缓存关联。 ``` aws elasticache describe-serverless-caches --serverless-cache-name { "..." "UserGroupId": "" "..." } ``` **禁用通过 AUTH 令牌配置的 Valkey 或 Redis OSS 缓存** 1. 将 AUTH 令牌更改为 RBAC 并指定要添加的用户组。 ``` aws elasticache modify-replication-group --replication-group-id --auth-token-update-strategy DELETE --user-group-ids-to-add ``` 1. 验证 AUTH 令牌是否已禁用以及是否添加了用户组。 ``` aws elasticache describe-replication-groups --replication-group-id { "..." "AuthTokenEnabled": false, "UserGroupIds": [ "" ] "..." } ``` 1. 删除用户组以禁用访问控制。 ``` aws elasticache modify-replication-group --replication-group-id --user-group-ids-to-remove { "..." "PendingModifiedValues": { "UserGroups": { "UserGroupIdsToAdd": [], "UserGroupIdsToRemove": [ "" ] } "..." } ``` 1. （可选）验证没有用户组与集群关联。`AuthTokenEnabled` 字段也应显示为 false。 ``` aws elasticache describe-replication-groups --replication-group-id "AuthTokenEnabled": false ``` **禁用配置了 RBAC 的 Valkey 或 Redis OSS 集群** 1. 删除用户组以禁用访问控制。 ``` aws elasticache modify-replication-group --replication-group-id --user-group-ids-to-remove { "..." "PendingModifiedValues": { "UserGroups": { "UserGroupIdsToAdd": [], "UserGroupIdsToRemove": [ "" ] } "..." } ``` 1. （可选）验证没有用户组与集群关联。`AuthTokenEnabled` 字段也应显示为 false。 ``` aws elasticache describe-replication-groups --replication-group-id "AuthTokenEnabled": false ```