本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# MemoryDB 中的数据保护
分 AWS [担责任模型](https://aws.amazon.com/compliance/shared-responsibility-model/)适用于中的数据保护。如本模型所述 AWS ，负责保护运行所有内容的全球基础架构 AWS 云。您负责维护对托管在此基础结构上的内容的控制。您还负责您所使用的 AWS 服务 的安全配置和管理任务。有关数据隐私的更多信息，请参阅[数据隐私常见问题](https://aws.amazon.com/compliance/data-privacy-faq/)。有关欧洲数据保护的信息，请参阅 *AWS Security Blog* 上的 [AWS Shared Responsibility Model and GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) 博客文章。
出于数据保护目的，我们建议您保护 AWS 账户 凭证并使用 AWS IAM Identity Center 或 AWS Identity and Access Management (IAM) 设置个人用户。这样，每个用户只获得履行其工作职责所需的权限。还建议您通过以下方式保护数据：
+ 对每个账户使用多重身份验证（MFA）。
+ 用于 SSL/TLS 与 AWS 资源通信。我们要求使用 TLS 1.2，建议使用 TLS 1.3。
+ 使用设置 API 和用户活动日志 AWS CloudTrail。有关使用 CloudTrail 跟踪捕获 AWS 活动的信息，请参阅《*AWS CloudTrail 用户指南》*中的[使用跟 CloudTrail 踪](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html)。
+ 使用 AWS 加密解决方案以及其中的所有默认安全控件 AWS 服务。
+ 使用高级托管安全服务（例如 Amazon Macie），它有助于发现和保护存储在 Amazon S3 中的敏感数据。
+ 如果您在 AWS 通过命令行界面或 API 进行访问时需要经过 FIPS 140-3 验证的加密模块，请使用 FIPS 端点。有关可用的 FIPS 端点的更多信息，请参阅《美国联邦信息处理标准（FIPS）第 140-3 版》[https://aws.amazon.com/compliance/fips/](https://aws.amazon.com/compliance/fips/)。
强烈建议您切勿将机密信息或敏感信息（如您客户的电子邮件地址）放入标签或自由格式文本字段（如**名称**字段）。这包括您使用控制台、API 或以其他 AWS 服务 方式使用控制台 AWS CLI、API 或时 AWS SDKs。在用于名称的标签或自由格式文本字段中输入的任何数据都可能会用于计费或诊断日志。如果您向外部服务器提供 URL，强烈建议您不要在网址中包含凭证信息来验证对该服务器的请求。
# MemoryDB 中的数据安全性
为了帮助确保数据安全，MemoryDB 和 Amazon EC2 提供了禁止未经授权访问服务器上数据的机制。
MemoryDB 还为集群中的数据提供加密功能：
+ 传输中加密可对从一个位置移动到另一个位置的数据进行加密，例如在集群中的节点之间或在集群与应用程序之间移动数据。
+ 静态加密可在快照操作期间对事务日志和磁盘上的数据进行加密。
您还可以使用 [使用访问控制列表对用户进行身份验证 () ACLs](clusters.acls.md) 控制用户对集群的访问。
**Topics**
+ [MemoryDB 中的数据安全性](encryption.md)
+ [MemoryDB 中的静态加密](at-rest-encryption.md)
+ [MemoryDB 传输中加密（TLS）](in-transit-encryption.md)
+ [使用访问控制列表对用户进行身份验证 () ACLs](clusters.acls.md)
+ [使用 IAM 进行身份验证](auth-iam.md)
# MemoryDB 中的静态加密
为了帮助保护您的数据，MemoryDB 和 Amazon S3 提供了不同的方法来限制对集群中的数据的访问。有关更多信息，请参阅[MemoryDB 和 Amazon VPC](vpcs.md)和[MemoryDB 中的身份和访问管理](iam.md)。
MemoryDB 静态加密始终通过加密永久数据来提高数据安全性。它对以下方面进行加密：
+ 事务日志中的数据
+ 同步、快照和交换操作期间的磁盘
+ 存储在 Amazon S3 中的快照
MemoryDB 提供默认（托管服务）的静态加密，以及在[AWS 密钥管理服务（KMS）](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) 中使用您自己的对称客户托管式根密钥的功能。
在预设情况下，在启用数据分层的集群中存储在 SSD（固态硬盘）上的数据始终加密。
有关传输中加密的信息，请参阅[MemoryDB 传输中加密（TLS）](in-transit-encryption.md)
**Topics**
+ [使用 AWS KMS 中的客户托管式密钥](#using-customer-managed-keys-for-memorydb-security)
+ [另请参阅](#at-rest-encryption-see-also)
## 使用 AWS KMS 中的客户托管式密钥
MemoryDB 支持对称的客户托管式根密钥（KMS 密钥），用于静态加密。客户自主管理型 KMS 密钥是您在自己的 AWS 账户中创建、拥有并管理的加密密钥。有关更多信息，请参阅*AWS密钥管理服务开发人员指南*中的[客户根密钥](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#root_keys)。必须先在 AWS KMS 中创建密钥，然后才能将其与 MemoryDB 一起使用。
要了解如何创建 AWS KMS 根密钥，请参阅 *AWS Key Management Service 开发人员指南*中的[创建密钥](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html)。
MemoryDB 允许您与 AWS KMS 集成。有关更多信息，请参阅 *AWS Key Management Service 开发人员指南*中的[使用授权](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)。无需任何客户操作即可实现 MemoryDB 与 AWS KMS 的集成。
`kms:ViaService` 条件键将 AWS KMS 密钥的使用限制为来自指定的 AWS 服务的请求。要将 `kms:ViaService` 与 MemoryDB 结合使用，请将两个 ViaService 名称包含在条件键值中： `memorydb.amazon_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) 来跟踪 MemoryDB 代表您向 AWS Key Management Service 发送的请求。对 AWS Key Management Service 发出的与客户自主管理型密钥相关的所有 API 调用都具有相应的 CloudTrail 日志。您还可以通过调用 [ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html) KMS API 调用来查看 MemoryDB 创建的授权。
使用客户托管式密钥对集群进行加密后，集群的所有快照都将按如下方式进行加密：
+ 使用与集群关联的客户托管式密钥对每日自动快照进行加密。
+ 删除集群时创建的最终快照也使用与集群关联的客户托管式密钥进行加密。
+ 默认情况下，使用与集群关联的密钥对手动创建的快照进行加密。您可以通过选择其他客户自主管理型密钥来覆此行为。
+ 复制快照将默认使用与源快照关联的客户托管式密钥。您可以通过选择其他客户自主管理型密钥来覆此行为。
**注意**
将快照导出到所选的 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)，则集群将变得不可恢复。换句话说，复制组在硬件故障后无法修改或恢复。AWSKMS 在至少七天的等待期限之后才会删除根密钥。删除密钥后，您可以使用其他客户托管式密钥创建快照以用于存档目的。
+ 自动密钥轮换将保留 AWS KMS 根密钥的属性，因此轮换不会影响您访问 MemoryDB 数据的能力。加密 MemoryDB 集群不支持手动密钥轮换，手动密钥轮换涉及创建新的根密钥和将任何参考更新到旧密钥。要了解详情，请参阅* AWS 密钥管理服务开发人员指南*中的[轮换客户根密钥](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html)。
+ 使用 KMS 密钥加密 MemoryDB 集群需要每个集群具有一个授权。在集群的整个生命周期中使用此授权。此外，在快照创建期间使用每个快照一个授权。在创建快照后，此授权将停用。
+ 有关 AWS KMS 授权和限制的更多信息，请参阅* AWS 密钥管理服务开发人员指南*中的[配额](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html)。
## 另请参阅
+ [MemoryDB 传输中加密（TLS）](in-transit-encryption.md)
+ [MemoryDB 和 Amazon VPC](vpcs.md)
+ [MemoryDB 中的身份和访问管理](iam.md)
# MemoryDB 传输中加密（TLS）
为了帮助确保数据安全，MemoryDB 和 Amazon EC2 提供了禁止未经授权访问服务器上数据的机制。通过传输中加密功能，MemoryDB 为您提供了在不同位置之间移动数据时用来保护数据的工具。例如，您可能从集群中的主节点向只读副本节点移动数据，或在集群与应用程序之间移动数据。
**Topics**
+ [传输中加密概览](#in-transit-encryption-overview)
+ [另请参阅](#in-transit-encryption-see-also)
## 传输中加密概览
MemoryDB 传输中加密是一项在数据最脆弱的时候（从一个位置传输到另一个位置时）提高数据安全性的特征。
MemoryDB 传输中加密可实现以下功能：
+ **加密连接** – 服务器和客户端连接都采用传输层安全性协议（TLS）加密。
+ **加密复制** – 对在主节点与副本节点之间移动的数据进行加密。
+ **服务器身份验证** – 客户端可通过身份验证确定它们连接到正确的服务器。
自 2023 年 7 月 20 日起，TLS 1.2 是新集群和现有集群的最低支持版本。使用此[链接](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/) 了解有关 TLS 1.2 的更多信息，网址：AWS。
有关连接到 MemoryDB 集群的更多信息，请参阅 [使用 redis-cli 连接到 MemoryDB 节点](getting-started.md#connect-tls)。
## 另请参阅
+ [MemoryDB 中的静态加密](at-rest-encryption.md)
+ [使用访问控制列表（ACL）对用户进行身份验证](https://docs.aws.amazon.com/memorydb/latest/devguide/clusters.acls.html)
+ [MemoryDB 和 Amazon VPC](vpcs.md)
+ [MemoryDB 中的身份和访问管理](iam.md)
# 使用访问控制列表对用户进行身份验证 () ACLs
您可以使用访问控制列表 (ACLs) 对用户进行身份验证。
ACLs 使您能够通过对用户进行分组来控制集群访问权限。这些访问控制列表旨在作为一种集群访问组织方式。
使用 ACLs，您可以创建用户并使用访问字符串为其分配特定权限，如下一节所述。您可以将用户分配到与特定角色（管理员、人力资源）一致的访问控制列表，然后将这些访问控制列表部署到一个或多个 MemoryDB 集群。这样，您可以在使用相同 MemoryDB 集群的客户端之间建立安全边界，并阻止客户端彼此访问数据。
ACLs 旨在支持在 Redis OSS 6 中引入 [ACL](https://valkey.io/docs/topics/acl/)。 ACLs 与 MemoryDB 集群一起使用时，存在一些限制：
+ 不能在访问字符串中指定密码。您可以通过[CreateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateUser.html)或[UpdateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateUser.html)呼叫来设置密码。
+ 对于用户权利，您可以将 `on` 和 `off` 作为访问字符串的一部分进行传递。如果两者在访问字符串中都未指定，则将为用户分配 `off` 并且用户没有访问集群的权限。
+ 您不能使用已禁止命令。如果您指定了已禁止命令，则会引发异常。有关此类命令列表，请参阅 [受限命令](restrictedcommands.md)。
+ 您不能将 `reset` 命令作为访问字符串的一部分。您可以使用 API 参数指定密码，MemoryDB 会管理这些密码。因此，您不能使用 `reset`，因为此命令会移除用户的所有密码。
+ Redis OSS 6 引入了 [ACL LIST](https://valkey.io/commands/acl-list) 命令。此命令将返回用户列表以及应用于各用户的 ACL 规则。MemoryDB 支持 `ACL LIST` 命令，但不像 Redis OSS 那样支持密码哈希。使用 MemoryDB，您可以使用该[DescribeUsers](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeUsers.html)操作来获取类似的信息，包括访问字符串中包含的规则。但是，[DescribeUsers](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeUsers.html)无法检索用户密码。
MemoryDB 支持的其他只读命令包括 [ACL WHOAMI](https://valkey.io/commands/acl-whoami)、[ACL USERS](https://valkey.io/commands/acl-users) 和 [ACL CAT](https://valkey.io/commands/acl-cat)。MemoryDB 不支持任何其他基于写入的 ACL 命令。
下文将详细介绍如何 ACLs 与 MemoryDB 配合使用。
**Topics**
+ [使用访问字符串指定权限](#access-string)
+ [向量搜索功能](#access-vss)
+ [ACLs 向集群申请 MemoryDB](#rbac-using)
## 使用访问字符串指定权限
要指定对 MemoryDB 集群的权限，您可以使用或创建访问字符串并将其分配给用户。 AWS CLI AWS 管理控制台
根据定义，访问字符串是指应用于用户的、以空格分隔的规则列表。它们定义了用户可以执行的命令以及用户可以对其进行操作的密钥。要执行命令，用户必须有权访问正在执行的命令以及命令访问的所有密钥。规则从左到右累积应用，如果提供的字符串中存在冗余，则可以使用更简单的字符串代替提供的字符串。
有关 ACL 规则的语法的信息，请参阅 [ACL](https://valkey.io/topics/acl)。
在以下示例中，访问字符串表示具有所有可用密钥和命令访问权限的活动用户。
`on ~* &* +@all`
访问字符串语法分解如下：
+ `on` – 用户是活动用户。
+ `~*` – 具有对所有可用密钥的访问权限。
+ `&*` – 具有对所有发布/订阅频道的访问权限。
+ `+@all` – 具有对所有可用命令的访问权限。
上述设置的限制性最小。您可以修改这些设置以使其更加安全。
在以下示例中，访问字符串表示一个用户，其访问权限限于对以“app::”键空间开头的键进行读取访问
`on ~app::* -@all +@read`
您可以通过列出用户有权访问的命令来进一步优化这些权限：
`+command1` – 用户对命令的访问被限制为 *`command1`*。
`+@category` – 用户的访问被限制为某个类别的命令。
有关向用户分配访问字符串的信息，请参阅 [使用控制台和 CLI 创建用户和访问控制列表](#users-management)。
如果要将现有工作负载迁移到 MemoryDB，则可以通过调用 `ACL LIST`（不包括用户和任何哈希密码）来检索访问字符串。
## 向量搜索功能
对于[向量搜索](vector-search.md)，所有搜索命令都属于该 `@search` 类别，而现有类别 `@read`、`@write`、`@fast` 和 `@slow` 则会更新为包括搜索命令。如果用户无权访问某个类别，那么该用户也无权访问该类别中的任何命令。例如，如果用户无权访问 `@search`，那么该用户也无法执行任何与搜索相关的命令。
下表指示搜索命令到相应类别的映射。
| VSS 命令 | @read | @write | @fast | @slow |
| --- | --- | --- | --- | --- |
| FT.CREATE | | Y | Y | |
| FT.DROPINDEX | | Y | Y | |
| FT.LIST | Y | | | Y |
| FT.INFO | Y | | Y | |
| FT.SEARCH | Y | | | Y |
| FT.AGGREGATE | Y | | | Y |
| FT.PROFILE | Y | | | Y |
| FT.ALIASADD | | Y | Y | |
| FT.ALIASDEL | | Y | Y | |
| FT.ALIASUPDATE | | Y | Y | |
| FT.\$1ALIASLIST | Y | | | Y |
| FT.EXPLAIN | Y | | Y | |
| FT.EXPLAINCLI | Y | | Y | |
| FT.CONFIG | Y | | Y | |
## ACLs 向集群申请 MemoryDB
要使用 MemoryDB ACLs，您需要执行以下步骤：
1. 创建一个或多个用户。
1. 创建 ACL 并将用户添加到此列表中。
1. 将 ACL 分配到集群。
下方详细地说明了这些步骤。
**Topics**
+ [使用控制台和 CLI 创建用户和访问控制列表](#users-management)
+ [使用控制台和 CLI 管理访问控制列表](#user-groups)
+ [将访问控制列表分配到集群](#users-groups-to-clusterss)
### 使用控制台和 CLI 创建用户和访问控制列表
用户的用户信息是 ACLs 用户名，也可以是密码和访问字符串（可选）。访问字符串提供对密钥和命令的权限级别。用户名对于用户是唯一的，是传递给引擎的内容。
确保您提供的 ACL 符合用户组的预期目的。例如，如果您创建一个名为 `Administrators` 的 ACL，则添加到该组的任何用户都应将其访问字符串设置为对密钥和命令具有完全访问权限。对于 `e-commerce` ACL 中的用户，您可以将其访问字符串设置为只读访问。
MemoryDB 为每个账户和用户名 `"default"` 自动配置一个默认用户。它未与任何集群关联，除非明确添加到 ACL 中。您无法修改或删除该用户。该用户旨在与以前 Redis OSS 版本的默认行为兼容，并具有一个访问字符串，允许它调用所有命令并访问所有密钥。
将为每个包含默认用户的账户创建一个不可变“开放访问”ACL。这是默认用户可加入的唯一的 ACL。当您创建一个集群时，必须选择一个与该集群关联的 ACL。虽然您可以选择对默认用户应用“开放访问”ACL，但我们强烈建议为权限仅限于其业务需求的用户创建 ACL。
未启用 TLS 的集群必须使用“开放访问”ACL 提供开放身份验证。
ACLs 可以在没有用户的情况下创建。空 ACL 无权访问集群，只能与启动 TLS 的集群关联。
创建用户时，最多可以设置两个密码。修改密码时，将保持与集群之间的所有现有连接。
特别是，在用于 MemoryDB 时，请注意以下用户密码限制： ACLs
+ 密码必须是 16-128 个可打印字符。
+ 不允许使用以下非字母数字字符：`,` `""` `/` `@`。
#### 使用控制台和 CLI 管理用户
##### 创建用户（控制台）
**在控制台上创建用户**
1. 登录 AWS 管理控制台 并打开 MemoryDB 控制台，网址为。[https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. 在左侧导航窗格中，选择**用户**。
1. 选择**创建用户**
1. 在**创建用户**页面上，输入**名称**。
集群命名约束如下：
+ 必须包含 1 – 40 个字母数字字符或连字符。
+ 必须以字母开头。
+ 不能包含两个连续连字符。
+ 不能以连字符结束。
1. 在**密码**下，最多可以输入两个密码。
1. 在**访问字符串**下，输入访问字符串。访问字符串设置允许用户使用的密钥和命令的权限级别。
1. 对于**标签**，您可以选择应用标签来搜索和筛选用户或跟踪您的 AWS 费用。
1. 选择**创建**。
##### 使用创建用户 AWS CLI
**使用 CLI 创建用户**
+ 使用 [create-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-user.html) 命令可创建新的用户。
对于 Linux、macOS 或 Unix：
```
aws memorydb create-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*" \
--authentication-mode \
Passwords="abc",Type=password
```
对于 Windows：
```
aws memorydb create-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*" ^
--authentication-mode \
Passwords="abc",Type=password
```
##### 修改用户（控制台）
**在控制台上修改用户**
1. 登录 AWS 管理控制台 并打开 MemoryDB 控制台，网址为。[https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. 在左侧导航窗格中，选择**用户**。
1. 选择要修改的用户旁边的单选按钮，然后选择**操作** -> **修改**
1. 如果要修改密码，请选择**修改密码**单选按钮。请注意，如设有两个密码，则修改其中之一时必须同时输入两个密码。
1. 如果要更新访问字符串，则请输入新的访问字符串。
1. 选择 **Modify**(修改)。
##### 使用修改用户 AWS CLI
**使用 CLI 修改用户**
1. 使用 [update-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-user.html) 命令修改用户。
1. 当修改用户时，与该用户关联的访问控制列表以及与 ACL 关联的任何集群将进行更新。将会保持所有现有连接。示例如下。
对于 Linux、macOS 或 Unix：
```
aws memorydb update-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*"
```
对于 Windows：
```
aws memorydb update-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*"
```
##### 查看用户详细信息（控制台）
**在控制台查看用户详细信息**
1. 登录 AWS 管理控制台 并打开 MemoryDB 控制台，网址为。[https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. 在左侧导航窗格中，选择**用户**。
1. 在**用户名**下选择用户或使用搜索框查找用户。
1. 在**用户设置**下，查看用户的访问字符串、密码数量、状态和 Amazon 资源名称（ARN）。
1. 在**访问控制列表（ACL）**下，查看用户所属的 ACL。
1. 在**标签**下，查看与用户关联的任何标签。
##### 使用查看用户详细信息 AWS CLI
使用 [describe-users](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-users.html) 命令查看用户的详细信息。
```
aws memorydb describe-users \
--user-name my-user-name
```
##### 删除 用户（控制台）
**在控制台上删除用户**
1. 登录 AWS 管理控制台 并打开 MemoryDB 控制台，网址为。[https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. 在左侧导航窗格中，选择**用户**。
1. 选择要修改的用户旁边的单选按钮，然后选择**操作** -> **删除**
1. 要进行确认，请在确认文本框中输入 `delete`，然后选择**确认**。
1. 要取消，请选择**取消**。
##### 使用删除用户 AWS CLI
**使用 CLI 删除用户**
+ 使用 [delete-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-user.html) 命令删除用户。
此账户将被删除并从其所属的任何访问控制列表中移除。示例如下：
对于 Linux、macOS 或 Unix：
```
aws memorydb delete-user \
--user-name user-name-2
```
对于 Windows：
```
aws memorydb delete-user ^
--user-name user-name-2
```
### 使用控制台和 CLI 管理访问控制列表
您可以创建访问控制列表来组织和控制用户对一个或多个集群的访问，如下所示。
使用以下步骤通过控制台管理访问控制列表。
#### 创建访问控制列表（ACL）（控制台）
**使用控制台创建访问控制列表**
1. 登录 AWS 管理控制台 并打开 MemoryDB 控制台，网址为。[https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. 在左侧导航窗格中，选择**访问控制列表（ACL）**。
1. 选择**创建 ACL**。
1. 在**创建访问控制列表（ACL）**页面上，输入 ACL 名称。
集群命名约束如下：
+ 必须包含 1 – 40 个字母数字字符或连字符。
+ 必须以字母开头。
+ 不能包含两个连续连字符。
+ 不能以连字符结束。
1. 在**选定用户**下，执行以下操作之一：
1. 通过选择**创建用户**创建新用户
1. 添加用户，方法是选择**管理**，再从**管理用户**对话框中选择用户，然后选择**选择**。
1. 对于**标签**，您可以选择应用标签来搜索和筛选您的费用 ACLs 或跟踪您的 AWS 费用。
1. 选择**创建**。
#### 使用创建访问控制列表 (ACL) AWS CLI
通过 CLI 使用以下过程创建访问控制列表。
**使用 CLI 创建新 ACL 并添加用户**
+ 使用 [create-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-acl.html) 命令创建 ACL。
对于 Linux、macOS 或 Unix：
```
aws memorydb create-acl \
--acl-name "new-acl-1" \
--user-names "user-name-1" "user-name-2"
```
对于 Windows：
```
aws memorydb create-acl ^
--acl-name "new-acl-1" ^
--user-names "user-name-1" "user-name-2"
```
#### 修改访问控制列表（ACL）（控制台）
**使用控制台修改访问控制列表**
1. 登录 AWS 管理控制台 并打开 MemoryDB 控制台，网址为。[https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. 在左侧导航窗格中，选择**访问控制列表（ACL）**。
1. 选择要修改的 ACL，然后选择 **修改**
1. 在**修改**页面的**所选用户**下，执行下列操作之一：
1. 通过选择**创建用户**添加到 ACL。
1. 添加或移除用户，方法是选择**管理**，再从**管理用户**对话框中选择或取消选中用户，然后选择**选择**。
1. 在**创建访问控制列表（ACL）**页面上，输入 ACL 名称。
集群命名约束如下：
+ 必须包含 1 – 40 个字母数字字符或连字符。
+ 必须以字母开头。
+ 不能包含两个连续连字符。
+ 不能以连字符结束。
1. 在**选定用户**下，执行以下操作之一：
1. 通过选择**创建用户**创建新用户
1. 添加用户，方法是选择**管理**，再从**管理用户**对话框中选择用户，然后选择**选择**。
1. 选择**修改**保存更改，或选择**取消**放弃更改。
#### 使用修改访问控制列表 (ACL) AWS CLI
**使用 CLI 通过添加新用户或移除当前成员来修改 ACL**
+ 使用 [update-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-acl.html) 命令修改 ACL。
对于 Linux、macOS 或 Unix：
```
aws memorydb update-acl --acl-name new-acl-1 \
--user-names-to-add user-name-3 \
--user-names-to-remove user-name-2
```
对于 Windows：
```
aws memorydb update-acl --acl-name new-acl-1 ^
--user-names-to-add user-name-3 ^
--user-names-to-remove user-name-2
```
**注意**
此命令将结束属于从 ACL 中移除的用户的任何打开的连接。
#### 查看访问控制列表（ACL）详细信息（控制台）
**在控制台上查看 ACL 详细信息**
1. 登录 AWS 管理控制台 并打开 MemoryDB 控制台，网址为。[https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. 在左侧导航窗格上，选择**访问控制列表（ACL）**。
1. 在 **ACL 名称**下选择 ACL 或使用搜索框查找 ACL。
1. 在**用户**下，查看与 ACL 关联的用户列表。
1. 在**关联集群**下，查看 ACL 所属的集群。
1. 在**标签**下，查看与 ACL 关联的任何标签。
#### 使用查看访问控制列表 (ACL) AWS CLI
使用 [describe-acls](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-acls.html) 命令查看 ACL 详细信息。
```
aws memorydb describe-acls \
--acl-name test-group
```
#### 删除访问控制列表（ACL）（控制台）
**使用控制台删除访问控制列表**
1. 登录 AWS 管理控制台 并打开 MemoryDB 控制台，网址为。[https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. 在左侧导航窗格中，选择**访问控制列表（ACL）**。
1. 选择要修改的 ACL，然后选择**删除**
1. 在**删除**页面上，在确认框中输入 `delete`，并选择**删除**或**取消**，以避免删除 ACL。
将删除 ACL 本身，而不是属于该组的用户。
#### 使用删除访问控制列表 (ACL) AWS CLI
**使用 CLI 删除 ACL**
+ 使用 [delete-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-acl.html) 命令删除 ACL。
对于 Linux、macOS 或 Unix：
```
aws memorydb delete-acl /
--acl-name
```
对于 Windows：
```
aws memorydb delete-acl ^
--acl-name
```
上述示例将返回以下响应。
```
aws memorydb delete-acl --acl-name "new-acl-1"
{
"ACLName": "new-acl-1",
"Status": "deleting",
"EngineVersion": "6.2",
"UserNames": [
"user-name-1",
"user-name-3"
],
"clusters": [],
"ARN":"arn:aws:memorydb:us-east-1:493071037918:acl/new-acl-1"
}
```
### 将访问控制列表分配到集群
创建 ACL 并添加用户后，实施的最后一步 ACLs 是将 ACL 分配给集群。
#### 使用控制台将访问控制列表分配到集群
要使用向集群添加 ACL AWS 管理控制台，请参阅[创建 MemoryDB 集群](getting-started.md#clusters.create)。
#### 为群集分配访问控制列表使用 AWS CLI
以下 AWS CLI 操作创建一个启用传输中加密 (TLS) 且**acl-name**参数值为的集群`my-acl-name`。用已存在的子网组替换子网组 `subnet-group`。
**关键参数**
+ **--engine-version** – 必须是 6.2。
+ **--tls-enabled** – 用于身份验证和关联 ACL。
+ **--acl-name** – 此值提供由具有集群指定访问权限的用户组成的访问控制列表。
对于 Linux、macOS 或 Unix：
```
aws memorydb create-cluster \
--cluster-name "new-cluster" \
--description "new-cluster" \
--engine-version "6.2" \
--node-type db.r6g.large \
--tls-enabled \
--acl-name "new-acl-1" \
--subnet-group-name "subnet-group"
```
对于 Windows：
```
aws memorydb create-cluster ^
--cluster-name "new-cluster" ^
--cluster-description "new-cluster" ^
--engine-version "6.2" ^
--node-type db.r6g.large ^
--tls-enabled ^
--acl-name "new-acl-1" ^
--subnet-group-name "subnet-group"
```
以下 AWS CLI 操作修改了启用传输中加密 (TLS) 且**acl-name**参数值`new-acl-2`为的集群。
对于 Linux、macOS 或 Unix：
```
aws memorydb update-cluster \
--cluster-name cluster-1 \
--acl-name "new-acl-2"
```
对于 Windows：
```
aws memorydb update-cluster ^
--cluster-name cluster-1 ^
--acl-name "new-acl-2"
```
# 使用 IAM 进行身份验证
**Topics**
+ [概述](#auth-iam-overview)
+ [限制](#auth-iam-limits)
+ [设置](#auth-iam-setup)
+ [连接](#auth-iam-Connecting)
## 概述
使用 IAM 身份验证，当您的集群配置为使用 Valkey 或 Redis OSS 版本 7 或更高版本时，您可以使用 AWS IAM 身份验证与 MemoryDB 的连接。这使您可以增强安全模型并简化许多管理安全任务。通过 IAM 身份验证，您可以为每个单独的 MemoryDB 集群和 MemoryDB 用户配置精细的访问控制，并遵循最低权限权限原则。MemoryDB 的 IAM 身份验证的工作原理是在 `AUTH` 或 `HELLO` 命令中提供有效期很短的 IAM 身份验证令牌，而不是有效期很长的 MemoryDB 用户密码。有关 IAM 身份验证令牌的更多信息，请参阅《 AWS 通用参考指南》中的[签名版本 4 签名流程](https://docs.aws.amazon.com//general/latest/gr/signature-version-4.html)和下面的代码示例。
您可以使用 IAM 身份及其关联策略进一步限制 Valkey 或 Redis OSS 访问权限。您还可以直接向来自联合身份提供商的用户授予对 MemoryDB 集群的访问权限。
要 AWS 将 IAM 与 MemoryDB 配合使用，您首先需要创建一个身份验证模式设置为 IAM 的 MemoryDB 用户，然后才能创建或重复使用 IAM 身份。IAM 身份需要关联策略才能向 MemoryDB 集群和 MemoryDB 用户授予 `memorydb:Connect` 操作权限。配置完成后，您可以使用 IAM 用户或角色的 AWS 证书创建 IAM 身份验证令牌。最后，在连接到 MemoryDB 集群节点时，您需要在 Valkey 或 Redis OSS 客户端中提供有效期较短的 IAM 身份验证令牌作为密码。支持凭证提供程序的客户端可以为每个新连接自动生成临时凭证。MemoryDB 将对启用 IAM 的 MemoryDB 用户的连接请求执行 IAM 身份验证，并将通过 IAM 验证连接请求。
## 限制
使用 IAM 身份验证时，以下限制适用：
+ 使用 Valkey 或 Redis OSS 引擎版本 7.0 或更高版本时，IAM 身份验证可用。
+ IAM 身份验证令牌的有效期为 15 分钟。对于长时间的连接，建议使用支持凭证提供程序接口的 Redis OSS 客户端。
+ 经过 IAM 身份验证的 MemoryDB 连接将在 12 小时后自动断开。通过使用新 IAM 身份验证令牌发送 `AUTH` 或 `HELLO` 命令，可以将连接延长 12 小时。
+ `MULTI EXEC` 命令不支持 IAM 身份验证。
+ 目前，IAM 身份验证并不支持所有的全局条件上下文键。有关全局条件上下文键的更多信息，请参阅《IAM 用户指南》中的 [AWS 全局条件上下文键](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)。
## 设置
要设置 IAM 身份验证，请执行以下操作：
1. 创建集群
```
aws memorydb create-cluster \
--cluster-name cluster-01 \
--description "MemoryDB IAM auth application"
--node-type db.r6g.large \
--engine-version 7.0 \
--acl-name open-access
```
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" : [
"memorydb:connect"
],
"Resource" : [
"arn:aws:memorydb:us-east-1:123456789012:cluster/cluster-01",
"arn:aws:memorydb:us-east-1:123456789012:user/iam-user-01"
]
}
]
}
```
------
1. 创建 IAM 角色。
```
aws iam create-role \
--role-name "memorydb-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. 创建 IAM 策略。
```
aws iam create-policy \
--policy-name "memorydb-allow-all" \
--policy-document file://policy.json
```
1. 向角色附加 IAM 策略。
```
aws iam attach-role-policy \
--role-name "memorydb-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/memorydb-allow-all"
```
1. 创建启用 IAM 的新用户。
```
aws memorydb create-user \
--user-name iam-user-01 \
--authentication-mode Type=iam \
--access-string "on ~* +@all"
```
1. 创建 ACL 并附加用户。
```
aws memorydb create-acl \
--acl-name iam-acl-01 \
--user-names iam-user-01
aws memorydb update-cluster \
--cluster-name cluster-01 \
--acl-name iam-acl-01
```
## 连接
**使用令牌作为密码进行连接**
您首先需要使用 [AWS SigV4 预签名请求](https://docs.aws.amazon.com//general/latest/gr/sigv4-signed-request-examples.html)生成有效期较短的 IAM 身份验证令牌。之后，您需要在连接到 MemoryDB 集群时提供 IAM 身份验证令牌作为密码，如下例所示。
```
String userName = "insert user name"
String clusterName = "insert cluster name"
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 MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(userName, iamAuthToken)
.build();
// Create a new Lettuce client
RedisClusterClient client = RedisClusterClient.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 ACTION_NAME = "connect";
private static final String SERVICE_NAME = "memorydb";
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final String userName;
private final String clusterName;
private final String region;
public IAMAuthTokenRequest(String userName, String clusterName, String region) {
this.userName = userName;
this.clusterName = clusterName;
this.region = region;
}
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(userName));
return request;
}
private URI getRequestUri() {
return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, clusterName));
}
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());
}
}
```
**使用凭证提供程序进行连接**
以下代码显示了如何使用 IAM 身份验证凭证提供程序通过 MemoryDB 进行身份验证。
```
String userName = "insert user name"
String clusterName = "insert cluster name"
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 MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
// Create a credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
userName, iamAuthTokenRequest, awsCredentialsProvider);
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(redisCredentialsProvider)
.build();
// Create a new Lettuce cluster client
RedisClusterClient client = RedisClusterClient.create(redisURI);
client.connect();
```
以下是 Lettuce 集群客户端的示例，该客户端将封装在凭证提供程序 IAMAuthTokenRequest 中，以便在需要时自动生成临时证书。
```
public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider {
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final AWSCredentialsProvider awsCredentialsProvider;
private final String userName;
private final IAMAuthTokenRequest iamAuthTokenRequest;
private final Supplier iamAuthTokenSupplier;
public RedisIAMAuthCredentialsProvider(String userName,
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(userName, iamAuthTokenSupplier.get()));
}
private String getIamAuthToken() {
return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
}
```