本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。 # 在 Amazon Keyspaces（Apache Cassandra 兼容）中管理无服务器资源 Amazon Keyspaces（Apache Cassandra 兼容）是一项无服务器服务。Amazon Keyspaces 将存储和 read/write 吞吐量资源直接分配给表，而不是通过集群中的节点为工作负载部署、管理和维护存储和计算资源。 Amazon Keyspaces 会根据表中存储的数据自动预置存储。它会在您写入、更新和删除数据时扩展和缩减存储，您只需为使用的存储付费。数据跨多个[可用区](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)复制，以实现高可用性。Amazon Keyspaces 会持续监控表的大小，以确定存储费用。有关 Amazon Keyspaces 如何计算可计费数据大小的更多信息，请参阅 [估算 Amazon Keyspaces 中的行大小](calculating-row-size.md)。 本章介绍了 Amazon Keyspaces 中资源管理的关键方面。 + **估算行大小** - 要估算 Amazon Keyspaces 中行的编码大小，请考虑分区键元数据、集群列元数据、列标识符、数据类型和行元数据等因素。此编码行大小用于计费、配额管理以及预置吞吐能力规划。 + **估算容量消耗** - 本节介绍关于如何估算常见场景（例如范围查询、限制查询、表扫描、轻量级事务、静态列和多区域表等）的读取和写入容量消耗的示例。您可以使用 Amazon CloudWatch 来监控实际容量利用率。有关使用进行监控的更多信息 CloudWatch，请参阅[使用亚马逊监控亚马逊密钥空间 CloudWatch](monitoring-cloudwatch.md)。 + **配置 read/write 容量模式**-您可以在两种容量模式之间进行选择，以处理表上的读取和写入： + **按需模式（默认）**- 按请求支付读取和写入吞吐量费用。Amazon Keyspaces 可以将容量即时扩展到之前达到的任意流量水平。 + **预置模式** - 提前指定所需的读取和写入容量单位数。此模式有助于保持可预测的吞吐量性能。 + **通过自动扩缩功能管理吞吐能力** - 对于预置表，您可以启用自动扩缩功能，根据实际应用程序流量自动调节吞吐能力。Amazon Keyspaces 使用目标跟踪来增加或减少预置容量，从而将利用率保持在您的指定目标。 + **有效使用容量爆增** - Amazon Keyspaces 提供了容量爆增功能，具体实现方式是通过保留一部分未使用的吞吐量用于应对流量峰值。这种灵活性允许偶尔出现超出预置吞吐量的突发活动。 要排查容量错误，请参阅[无服务器容量错误](troubleshooting.serverless.md#troubleshooting-serverless)。 **Topics** + [估算 Amazon Keyspaces 中的行大小](calculating-row-size.md) + [估算 Amazon Keyspaces 中读取和写入吞吐量的容量消耗](capacity-examples.md) + [在 Amazon Keyspaces 中配置 read/write 容量模式](ReadWriteCapacityMode.md) + [使用 Amazon Keyspaces 自动扩缩自动管理吞吐能力](autoscaling.md) + [在 Amazon Keyspaces 中有效使用容量爆增](throughput-bursting.md) # 估算 Amazon Keyspaces 中的行大小 Amazon Keyspaces 提供完全托管的存储，可提供个位数毫秒的读取和写入性能，并在多个可用区中持久存储数据。 AWS Amazon Keyspaces 将元数据附加到所有行和主键列，以支持高效的数据访问和高可用性。 本主题详细介绍了如何估计 Amazon Keyspaces 中行的编码大小。在计算账单和限额使用量时，应使用编码行大小。在估算表的预配置吞吐量容量要求时，也可以使用编码后的行大小。 要计算 Amazon Keyspaces 中的编码行大小，可以遵循以下准则。 **Topics** + [估计列的编码大小](#calculating-row-size-columns) + [根据数据类型估计数据值的编码大小](#calculating-row-size-data-types) + [考虑一下 Amazon Keyspaces 功能对行大小的影响](#calculating-row-size-features) + [选择正确的公式来计算一行的编码大小](#calculating-row-size-formula) + [行大小计算示例](#calculating-row-size-example) ## 估计列的编码大小 本节介绍如何估计 Amazon Keyspaces 中列的编码大小。 + **常规列**-对于常规列（即不是主键的列）、聚类列或`STATIC`列，请根据数据[类型](cql.elements.md#cql.data-types)使用单元格数据的原始大小并添加所需的元数据。下一节将列出数据类型以及 Amazon Keyspaces 存储数据类型值和元数据方式的一些主要区别。 + **分区键列**-分区键最多可包含 2048 字节的数据。分区键中的每个键列最多需要 3 个字节的元数据。计算行大小时，应假设每个分区键列使用全部 3 个字节的元数据。 + **聚类列**-群集列最多可以存储 850 字节的数据。除了数据值的大小外，每个聚类列还要求元数据占数据值大小的 20%。计算行大小时，应为每 5 个字节的聚类列数据值添加 1 个字节的元数据。 **注意** 为了支持高效的查询和内置索引，Amazon Keyspaces 将每个分区键和集群键列的数据值存储两次。 + **列名**-使用列标识符存储每个列名所需的空间，并将其添加到列中存储的每个数据值中。列标识符的存储值取决于表中列的总数： + 1–62 个列：1 个字节 + 63–124 个列：2 个字节 + 125–186 个列：3 个字节 每增加 62 个列，添加 1 个字节。请注意，在 Amazon Keyspaces 中，使用单个 `INSERT` 或 `UPDATE` 语句最多可修改 225 个常规列。有关更多信息，请参阅 [Amazon Keyspaces 服务限额](quotas.md#table)。 ## 根据数据类型估计数据值的编码大小 本节介绍如何估计 Amazon Keyspaces 中不同数据类型的编码大小。 + **字符串类型** — Cassandra `ASCII` `TEXT`、和`VARCHAR`字符串数据类型都使用采用 UTF-8 二进制编码的 Unicode 存储在 Amazon Keyspaces 中。Amazon Keyspaces 中的字符串大小等于 UTF-8 编码的字节数。 + **数字类型** — Cassandra `INT` `BIGINT`、、`SMALLINT``TINYINT`、和`VARINT`数据类型作为长度可变的数据值存储在 Amazon Keyspaces 中，最多包含 38 位有效数字。系统会删减开头和结尾的 0。其中任何一种数据类型的大小约为每两个有效数字 1 个字节 \$1 1 个字节。 + **Blob 类型** — Amazon Keyspaces `BLOB` 中的 A 以该值的原始字节长度存储。 + **布尔类型**-值或`Boolean`值的大小`Null`为 1 字节。 + **集合类型**-存储集合数据类型（如`LIST`或`MAP`需要 3 字节的元数据）的列，无论其内容如何。`LIST` 或 `MAP` 的大小为（列 ID）\$1 总和（嵌套元素的大小）\$1（3 个字节）。空 `LIST` 或 `MAP` 的大小为（列 ID）\$1（3 个字节）。每个单个 `LIST` 或 `MAP` 元素还需要 1 个字节的元数据。 + **用户定义类型**-[用户定义类型 (UDT)](udts.md) 无论其内容如何，都需要 3 个字节的元数据。对于每个 UDT 元素，Amazon Keyspaces 需要额外提供 1 字节的元数据。 要计算 UDT 的编码大小，请从 UDT 字段`field value`的`field name`和开始： + **字段名**-顶级 UDT 的每个字段名都使用标识符存储。标识符的存储值取决于顶级 UDT 中字段的总数，可以在 1 到 3 个字节之间变化： + 1—62 个字段：1 个字节 + 63—124 个字段：2 个字节 + 125— 最大字段数：3 个字节 + **字段值**-存储顶级 UDT 的字段值所需的字节取决于存储的数据类型： + **标量数据类型**-存储所需的字节与存储在常规列中的相同数据类型所需的字节相同。 + **冻结 UDT**-对于每个冻结的嵌套 UDT，嵌套 UDT 的大小与 CQL 二进制协议中的大小相同。对于嵌套的 UDT，每个字段（包括空字段）存储 4 个字节，存储字段的值是字段值的 CQL 二进制协议序列化格式。 + **冰雪奇缘系列**： + L@@ **IS** T and SE **T** — 对于嵌套的冻结`LIST`或`SET`，为集合的每个元素存储 4 个字节，再加上集合值的 CQL 二进制协议序列化格式。 + MA@@ **P** — 对于嵌套的冻结`MAP`，每个键值对都有以下存储要求： + 为每个密钥分配 4 个字节，然后添加密钥的 CQL 二进制协议序列化格式。 + 为每个值分配 4 个字节，然后添加该值的 CQL 二进制协议序列化格式。 + F@@ **ROZEN 关键字** — 对于嵌套在冻结馆藏中的冻结集合，Amazon Keyspaces 不需要任何额外的字节来存储元数据。 + S@@ **TATIC 关键字**-`STATIC` 列数据不计入最大行大小 1 MB。要计算静态列的数据大小，请参阅[计算 Amazon Keyspaces 中每个逻辑分区静态列的大小](static-columns-estimate.md)。 ## 考虑一下 Amazon Keyspaces 功能对行大小的影响 本节显示 Amazon Keyspaces 中的功能如何影响行的编码大小。 + **客户端时间戳** — 开启该功能时，会为每行中的每一列存储客户端时间戳。这些时间戳大约占用 20-40 字节（取决于您的数据），并会增加该行的存储和吞吐量成本。有关客户端时间戳的更多信息，请参阅。[Amazon Keyspaces 中的客户端时间戳](client-side-timestamps.md) + **生存时间 (TTL)** — 开启该功能后，TTL 元数据每行占用大约 8 个字节。此外，还会为每行的每一列存储 TTL 元数据。每列存储标量数据类型或冻结集合，TTL 元数据占用大约 8 个字节。如果该列存储的集合数据类型未冻结，则对于集合中的每个元素，TTL 需要大约 8 个额外的元数据字节。对于启用 TTL 时存储集合数据类型的列，可以使用以下公式。 ``` total encoded size of column = (column id) + sum (nested elements + collection metadata (1 byte) + TTL metadata (8 bytes)) + collection column metadata (3 bytes) ``` TTL 元数据会占该行的存储和吞吐量成本。有关 TTL 的更多信息，请参阅 [使用 Amazon Keyspaces（Apache Cassandra 兼容）的生存时间（TTL）功能让数据过期](TTL.md)。 ## 选择正确的公式来计算一行的编码大小 本节显示了不同的公式，您可以使用这些公式来估计 Amazon Keyspaces 中一行数据的存储或容量吞吐量需求。 根据您的目标，可以根据以下公式之一估算出一行数据的总编码大小： + **吞吐容量**-要估计一行的编码大小以评估所需的 read/write 请求单位 (RRUs/WRUs) or read/write capacity units (RCUs/WCUs)： ``` total encoded size of row = partition key columns + clustering columns + regular columns ``` + **存储大小**-要估计行的编码大小以预测`BillableTableSizeInBytes`，请添加该行存储所需的元数据： ``` total encoded size of row = partition key columns + clustering columns + regular columns + row metadata (100 bytes) ``` **重要** 所有列元数据，例如列 ID、分区键元数据、群集列元数据以及客户端时间戳、TTL 和行元数据，都计入最大行大小 1 MB。 ## 行大小计算示例 考虑以下表示例，其中所有列均为整数类型。此表包含两个分区键列、两个聚类列和一个常规列。由于此表包含五列，因此列名称标识符所需的空间为 1 个字节。 ``` CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, primary key((pk_col1, pk_col2),ck_col1, ck_col2)); ``` 在此示例中，我们在向表中写入一行时计算数据的大小，如以下语句所示： ``` INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1) values(1,2,3,4,5); ``` 要估算此写入操作所需的总字节数，可以按照以下步骤操作。 1. 通过将存储在一个分区键列中的数据类型的字节和元数据字节相加，计算该列的大小。针对所有分区键列重复此操作。 1. 计算分区键第一列 (pk\$1col1) 的大小： ``` (2 bytes for the integer data type) x 2 + 1 byte for the column id + 3 bytes for partition key metadata = 8 bytes ``` 1. 计算分区键第二列 (pk\$1col2) 的大小： ``` (2 bytes for the integer data type) x 2 + 1 byte for the column id + 3 bytes for partition key metadata = 8 bytes ``` 1. 将两列相加，得出分区键列的估算总大小： ``` 8 bytes + 8 bytes = 16 bytes for the partition key columns ``` 1. 通过将存储在一个聚类列中的数据类型的字节和元数据字节相加，计算该列的大小。针对所有聚类列重复此操作。 1. 计算聚类列第一列 (ck\$1col1) 的大小： ``` (2 bytes for the integer data type) x 2 + 20% of the data value (2 bytes) for clustering column metadata + 1 byte for the column id = 6 bytes ``` 1. 计算聚类列第二列 (ck\$1col2) 的大小： ``` (2 bytes for the integer data type) x 2 + 20% of the data value (2 bytes) for clustering column metadata + 1 byte for the column id = 6 bytes ``` 1. 将两列相加，得出聚类列的估算总大小： ``` 6 bytes + 6 bytes = 12 bytes for the clustering columns ``` 1. 加上常规列的大小。在此示例中，我们只有一个列用于存储一个个位数整数，这需要 2 个字节，另外列 ID 还需要 1 个字节。 1. 最后，要获得编码后的总行大小，请将所有列的字节数相加。要估算存储的计费大小，请为行元数据添加额外 100 字节： ``` 16 bytes for the partition key columns + 12 bytes for clustering columns + 3 bytes for the regular column + 100 bytes for row metadata = 131 bytes. ``` 要了解如何使用 Amazon 监控无服务器资源 CloudWatch，请参阅[使用亚马逊监控亚马逊密钥空间 CloudWatch](monitoring-cloudwatch.md)。 # 估算 Amazon Keyspaces 中读取和写入吞吐量的容量消耗 当您在 Amazon Keyspaces 中读取或写入数据时，您的查询消耗的 read/write 请求单位 (RRUs/WRUs) or read/write capacity units (RCUs/WCUs) 数量取决于亚马逊密钥空间为运行查询而必须处理的数据总量。在某些情况下，返回给客户端的数据可能是 Amazon Keyspaces 为处理查询而必须读取的部分数据。对于条件写入，即使条件检查失败，Amazon Keyspaces 也会消耗写入容量。 要估算请求处理的数据总量，必须考虑行的编码大小和总行数。本主题涵盖一些常见场景和访问模式的示例，向您展示 Amazon Keyspaces 如何处理查询以及对容量消耗的影响。您可以按照示例估算表的容量需求，并使用 Amazon CloudWatch 观察这些用例的读取和写入容量消耗。 有关如何计算 Amazon Keyspaces 中行的编码大小的信息，请参阅[估算 Amazon Keyspaces 中的行大小](calculating-row-size.md)。 **Topics** + [估算 Amazon Keyspaces 中范围查询的容量消耗](range_queries.md) + [估算限制查询的读取容量消耗](limit_queries.md) + [估算表扫描的读取容量消耗](table_scans.md) + [估算 Amazon Keyspaces 中轻量级事务的容量消耗](lightweight_transactions.md) + [估算 Amazon Keyspaces 中静态列的容量消耗](static-columns.md) + [在 Amazon Keyspaces 中为多区域表估算和预置容量](tables-multi-region-capacity.md) + [估算亚马逊 CloudWatch 在 Amazon Keyspaces 中的读取和写入容量消耗](estimate_consumption_cw.md) # 估算 Amazon Keyspaces 中范围查询的容量消耗 要查看范围查询的读取容量消耗，我们使用以下示例表，该表使用按需容量模式。 ``` pk1 | pk2 | pk3 | ck1 | ck2 | ck3 | value -----+-----+-----+-----+-----+-----+------- a | b | 1 | a | b | 50 | a | b | 1 | a | b | 60 | value_1 a | b | 1 | a | b | 70 | ``` 现在，对该表运行以下查询。 ``` SELECT * FROM amazon_keyspaces.example_table_1 WHERE pk1='a' AND pk2='b' AND pk3=1 AND ck1='a' AND ck2='b' AND ck3 > 50 AND ck3 < 70; ``` 您从查询中收到以下结果集，Amazon Keyspaces 执行的读取操作 RRUs 在一`LOCAL_QUORUM`致模式下消耗 2。 ``` pk1 | pk2 | pk3 | ck1 | ck2 | ck3 | value -----+-----+-----+-----+-----+-----+------- a | b | 1 | a | b | 60 | value_1 ``` Amazon Keyspaces 消耗 2 RRUs 来评估包含这些值的行`ck3=60``ck3=70`并处理查询。但是，Amazon Keyspaces 仅返回查询中指定的 `WHERE` 条件为 true 的行，即值为 `ck3=60` 的行。为了评估查询中指定的范围，Amazon Keyspaces 会读取与该范围上限匹配的行（在本例中为 `ck3 = 70`），但不会在结果中返回该行。读取容量消耗基于处理查询时读取的数据，而不是返回的数据。 # 估算限制查询的读取容量消耗 在处理使用 `LIMIT` 子句的查询时，Amazon Keyspaces 会在尝试匹配查询中指定的条件时读取达到最大页面大小的行数。如果 Amazon Keyspaces 找不到符合第一页上 `LIMIT` 值的足够多的匹配数据，则可能需要进行一次或多次分页调用。要继续阅读下一页，可以使用分页令牌。默认页面大小为 1MB。如果希望在使用 `LIMIT` 子句时消耗较少的读取容量，可以缩小页面大小。有关分页的更多信息，请参阅[对 Amazon Keyspaces 中的结果进行分页](paginating-results.md)。 例如，我们来看下以下查询。 ``` SELECT * FROM my_table WHERE partition_key=1234 LIMIT 1; ``` 如果您不设置页面大小，Amazon Keyspaces 会读取 1MB 的数据，即使它只向您返回 1 行。要让 Amazon Keyspaces 只读取一行，您可以将此查询的页面大小设置为 1。在这种情况下，Amazon Keyspaces 只能读取一行，前提是您没有基于 Time-to-live设置或客户端时间戳的过期行。 该`PAGE SIZE`参数决定了 Amazon Keyspaces 为每个请求从磁盘扫描多少行，而不是 Amazon Keyspaces 返回给客户端的行数。Amazon Keyspaces 会应用您提供的筛选条件，例如非键列上的不等式，或者在扫描磁盘上的数据`LIMIT`之后。如果您未明确设置`PAGE SIZE`，Amazon Keyspaces 会在应用筛选条件之前读取最多 1MB 的数据。例如，如果您在使用时`LIMIT 1`未指定`PAGE SIZE`，Amazon Keyspaces 可能会在应用限制子句之前从磁盘读取数千行并仅返回一行。 为避免过度读取，请减少读取，这样`PAGE SIZE`可以减少 Amazon Keyspaces 每次读取时扫描的行数。例如，如果您在查询`LIMIT 5`中定义，请将设置为介于 5-10 之间的值，这样 Amazon Keyspaces 在每次分页调用时仅扫描 5-10 行。`PAGE SIZE`您可以修改此数字以减少读取次数。对于大于页面大小的限制，Amazon Keyspaces 会按分页状态保留结果总数。如果是 10,000 行，Amazon Keyspaces 可以将这些结果分成两页，每页 5,000 行。`LIMIT`1MB 限制是任何页面大小设置的上限。 # 估算表扫描的读取容量消耗 导致全表扫描的查询（例如使用 `ALLOW FILTERING` 选项的查询）是处理的读取数量多于返回结果的另一种查询示例。读取容量消耗基于读取的数据，而不是返回的数据。 对于表扫描示例，我们在按需容量模式下使用以下示例表。 ``` pk | ck | value ---+----+--------- pk | 10 | pk | 20 | value_1 pk | 30 | ``` 默认情况下，Amazon Keyspaces 会在按需容量模式下创建一个具有四个分区的表。在此示例表中，所有数据都存储在一个分区中，其余三个分区为空。 现在，对表运行以下查询。 ``` SELECT * from amazon_keyspaces.example_table_2; ``` 此查询将生成表扫描操作，其中 Amazon Keyspaces 会扫描表的所有四个分区，并在一致性模式下消耗 6 RRUs 个`LOCAL_QUORUM`分区。首先，Amazon Keyspaces 在读 RRUs 取三行时消耗 3。`pk=‘pk’`然后，Amazon Keyspaces 会额外消耗 3 个 RRUs 用于扫描表的三个空分区。由于此查询会导致表扫描，因此 Amazon Keyspaces 会扫描表中的所有分区，包括没有数据的分区。 # 估算 Amazon Keyspaces 中轻量级事务的容量消耗 轻量级事务（LWT）支持您对表数据执行条件写入操作。根据评估当前状态的条件插入、更新和删除记录时，条件更新操作非常有用。 在 Amazon Keyspaces 中，所有写入操作都需要 LOCAL\$1QUORUM 一致性，使用时不收取额外费用。 LWTs的区别在 LWTs 于，当 LWT 条件检查生效时`FALSE`，Amazon Keyspaces 会消耗写入容量单位 WCUs () 或写入请求单位 ()。WRUs WCUs/WRUs 消耗的数量取决于行的大小。 例如，如果行大小为 2 KB，则失败的条件写入将消耗两个 WCUs/WRUs。如果表中当前不存在该行，则该操作将消耗一个 WCUs/WRUs。 要确定导致条件检查失败的请求数，可以在中监控`ConditionalCheckFailed`指标 CloudWatch。 ## 估算带存活时间 (TTL) 的牌桌的 LWT 成本 LWTs 对于配置了 TTL 但不使用客户端时间戳的表，可能需要额外的读取容量单位 (RCUsRRUs) 或读取请求单位 ()。使用`IF EXISTS`或`IF NOT EXISTS`关键字条件检查结果时`FALSE`，会消耗以下容量单位： + RCUs/RRUs – If the row exists, the RCUs/RRUs消耗量基于现有行的大小。 + RCUs/RRUs – If the row doesn't exist, a single RCU/RRU被消耗掉了。 如果评估的条件导致写入操作成功， WCUs/WRUs 则根据新行的大小进行消费。 # 估算 Amazon Keyspaces 中静态列的容量消耗 在包含聚类列的 Amazon Keyspaces 表中，您可以使用 `STATIC` 关键字来创建静态列。存储在静态列中的值在逻辑分区的所有行之间共享。当您更新此列的值时，Amazon Keyspaces 会自动将更改应用于该分区中的所有行。 本节介绍在写入静态列时如何计算编码数据大小。此过程与将数据写入行中的非静态列的过程是分开处理的。除了静态数据的大小限额外，对静态列的读取和写入操作也会单独影响表的计量和吞吐容量。如需了解使用静态列和分页范围读取结果时 Apache Cassandra 的功能差异，请参阅[分页](functional-differences.md#functional-differences.paging)。 **Topics** + [计算 Amazon Keyspaces 中每个逻辑分区静态列的大小](static-columns-estimate.md) + [估算对 Amazon Keyspaces 中的静态数据进行 read/write 操作所需的容量吞吐量](static-columns-metering.md) # 计算 Amazon Keyspaces 中每个逻辑分区静态列的大小 本节详细介绍如何估算 Amazon Keyspaces 中的编码静态列大小。在计算账单和限额使用量时，应使用编码大小。在计算表的预置吞吐容量需求时，也应使用编码大小。要计算 Amazon Keyspaces 中的编码静态列大小，可以遵循以下准则。 + 分区键最多可包含 2048 个字节的数据。分区键中的每个键列最多需要 3 个字节的元数据。这些元数据字节计入每个分区 1MB 的静态数据大小限额。计算静态数据大小时，应假设每个分区键列使用全部 3 个字节的元数据。 + 根据数据类型使用静态列数据值的原始大小。有关数据类型的更多信息，请参阅 [数据类型](cql.elements.md#cql.data-types)。 + 在元数据的静态数据大小上增加 104 个字节。 + 聚类列和常规非主键列不计入静态数据的大小。要了解如何估算行中的非静态数据大小，请参阅[估算 Amazon Keyspaces 中的行大小](calculating-row-size.md)。 编码静态列的总大小基于以下公式： ``` partition key columns + static columns + metadata = total encoded size of static data ``` 考虑以下表示例，其中所有列均为整数类型。此表包含两个分区键列、两个聚类列、一个常规列和一个静态列。 ``` CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2)); ``` 在此示例中，我们计算以下语句的静态数据大小： ``` INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, static_col1) values(1,2,6); ``` 要估算此写入操作所需的总字节数，可以按照以下步骤操作。 1. 通过将存储在一个分区键列中的数据类型的字节和元数据字节相加，计算该列的大小。针对所有分区键列重复此操作。 1. 计算分区键第一列 (pk\$1col1) 的大小： ``` 4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes ``` 1. 计算分区键第二列 (pk\$1col2) 的大小： ``` 4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes ``` 1. 将两列相加，得出分区键列的估算总大小： ``` 7 bytes + 7 bytes = 14 bytes for the partition key columns ``` 1. 加上静态列的大小。在此示例中，我们只有一个静态列用于存储一个整数（需要 4 个字节）。 1. 最后，要得出编码静态列数据的总大小，请将主键列和静态列的字节相加，再加上元数据所需的 104 个字节： ``` 14 bytes for the partition key columns + 4 bytes for the static column + 104 bytes for metadata = 122 bytes. ``` 您也可以使用相同的语句更新静态数据和非静态数据。要估算写入操作的总大小，必须先计算非静态数据更新的大小。然后计算行更新的大小（如[估算 Amazon Keyspaces 中的行大小](calculating-row-size.md)中的示例所示），并将结果相加。 在此示例中，您总共可以写入 2MB，1MB 是最大行大小限额，1MB 是每个逻辑分区的最大静态数据大小限额。 要计算同一语句中静态数据和非静态数据更新的总大小，可以使用以下公式： ``` (partition key columns + static columns + metadata = total encoded size of static data) + (partition key columns + clustering columns + regular columns + row metadata = total encoded size of row) = total encoded size of data written ``` 考虑以下表示例，其中所有列均为整数类型。此表包含两个分区键列、两个聚类列、一个常规列和一个静态列。 ``` CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2)); ``` 在此示例中，我们在向表中写入一行时计算数据的大小，如以下语句所示： ``` INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1, static_col1) values(2,3,4,5,6,7); ``` 要估算此写入操作所需的总字节数，可以按照以下步骤操作。 1. 按照之前的步骤计算编码静态数据的总大小。在此示例中，它是 122 个字节。 1. 按照[估算 Amazon Keyspaces 中的行大小](calculating-row-size.md)中的步骤，根据非静态数据的更新，加上编码行总大小。在此示例中，行更新的总大小为 134 个字节。 ``` 122 bytes for static data + 134 bytes for nonstatic data = 256 bytes. ``` # 估算对 Amazon Keyspaces 中的静态数据进行 read/write 操作所需的容量吞吐量 静态数据与 Cassandra 中的逻辑分区相关联，而不是与单个行相关联。Amazon Keyspaces 中的逻辑分区跨越多个物理存储分区，实际上可以不受大小限制。因此，Amazon Keyspaces 分别计量静态数据和非静态数据的写入操作。此外，同时包含静态数据和非静态数据的写入操作需要额外的底层操作来提供数据一致性。 如果您执行包含静态数据和非静态数据的混合写入操作，则会产生两个不同的写入操作，一个用于非静态数据，另一个用于静态数据。这适用于按需和预配置 read/write 容量模式。 以下示例详细介绍了在计算 Amazon Keyspaces 中具有静态列的表的预配置吞吐量需求时，如何估算所需的读取容量单位 (RCUsWCUs) 和写入容量单位 ()。您可以使用以下公式估算表处理同时包含静态数据和非静态数据的写入操作所需的容量： ``` 2 x WCUs required for nonstatic data + 2 x WCUs required for static data ``` 例如，如果您的应用程序每秒写入 27 KBs 个数据，并且每次写入包括 25.5 个 KBs 非静态数据和 1. KBs 5 个静态数据，则您的表需要 56 WCUs （2 x 26 WCUs \$1 2 x 2 WCUs）。 Amazon Keyspaces 计量静态数据和非静态数据的读取方式与计量多行读取的方式相同。因此，在同一操作中读取静态数据和非静态数据的价格取决于为执行读取而处理的数据的总大小。 要了解如何使用 Amazon 监控无服务器资源 CloudWatch，请参阅[使用亚马逊监控亚马逊密钥空间 CloudWatch](monitoring-cloudwatch.md)。 # 在 Amazon Keyspaces 中为多区域表估算和预置容量 您可以通过以下两种方式之一配置多区域表的吞吐能力： + 按需容量模式，以写入请求单位衡量 (WRUs) + 带有 auto Scaling 功能的预置容量模式，以写入容量单位衡量 () WCUs 您可以将预置容量模式与 auto scaling 或按需容量模式配合使用，以帮助确保多区域表具有足够的容量来执行对所有表的复制写入。 AWS 区域 **注意** 在其中一个区域中更改表的容量模式会更改所有副本的容量模式。 默认情况下，Amazon Keyspaces 对多区域表使用按需模式。对于按需模式，您无需指定预期应用程序执行的读写吞吐量。Amazon Keyspaces 会随着工作负载的增加或减少，根据之前达到的任意流量水平即时调节工作负载。如果某个工作负载的流量级别达到一个新的峰值，Amazon Keyspaces 将快速调整以适应该工作负载。 如果您为表选择预置容量模式，则必须配置应用程序所需的每秒读取容量单位 (RCUs) 和写入容量单位 (WCUs) 的数量。 要规划多区域表的吞吐容量需求，应首先估计每个区域 WCUs 每秒所需的吞吐量容量。之后，将复制了表的所有区域的写入容量相加，然后使用该总和为每个区域预置容量。这是必需的操作，因为在一个区域中执行的每一次写入也必须在每个副本区域中重复执行。 如果表没有足够的容量来处理所有区域的写入操作，则会出现容量异常。此外，区域间的复制等待时间也将增加。 例如，如果您有一个多区域表，预计美国东部（弗吉尼亚北部）每秒 5 次写入，美国东部（俄亥俄州）每秒 10 次写入，欧洲（爱尔兰）每秒 5 次写入，则应预计该表在每个区域 WCUs 中消耗 20 次写入：美国东部（弗吉尼亚北部）、美国东部（俄亥俄州）和欧洲（爱尔兰）。这意味着在本示例中，您需要 WCUs 为表的每个副本预置 20。您可以使用 Amazon 监控表的容量消耗 CloudWatch。有关更多信息，请参阅 [使用亚马逊监控亚马逊密钥空间 CloudWatch](monitoring-cloudwatch.md)。 每次写入均按 1 个 WCU 计费，因此在本示例中，您会看到总共计有 60 个 WCU WCUs 计费。有关定价的更多信息，请参阅 [Amazon Keyspaces（Apache Cassandra 兼容）定价](https://aws.amazon.com/keyspaces/pricing)。 有关使用 Amazon Keyspaces 自动扩缩预置容量的更多信息，请参阅[使用 Amazon Keyspaces 自动扩缩自动管理吞吐能力](autoscaling.md)。 **注意** 如果表在具有自动扩缩功能的预置容量模式下运行，则允许预置的写入容量在每个区域的这些自动扩缩设置中浮动。 # 估算亚马逊 CloudWatch 在 Amazon Keyspaces 中的读取和写入容量消耗 要估算和监控读取和写入容量消耗，您可以使用 CloudWatch 控制面板。有关 Amazon Keyspaces 的可用指标的更多信息，请参阅[Amazon Keyspaces 指标与维度](metrics-dimensions.md)。 要监控特定语句使用的读取和写入容量单位 CloudWatch，可以按照以下步骤操作。 1. 创建一个包含样本数据的新表 1. 为表格配置 Amazon Keyspaces CloudWatch 控制面板。首先，您可以使用 [Github](https://github.com/aws-samples/amazon-keyspaces-cloudwatch-cloudformation-templates) 上提供的控制面板模板。 1. 运行 CQL 语句，例如使用 `ALLOW FILTERING` 选项，然后在控制面板中检查全表扫描所消耗的读取容量单位。 # 在 Amazon Keyspaces 中配置 read/write 容量模式 Amazon Keyspaces 有两种 read/write 容量模式用于处理表上的读取和写入： + 按需（默认） + 已预置 您选择的 read/write 容量模式控制如何对读取和写入吞吐量收费，以及如何管理表吞吐量容量。 **Topics** + [配置按需容量模式](ReadWriteCapacityMode.OnDemand.md) + [配置预置容量模式](ReadWriteCapacityMode.Provisioned.md) + [在 Amazon Keyspaces 中查看表的容量模式](ReadWriteCapacityMode.ProvisionedThroughput.ManagingCapacity.md) + [在 Amazon Keyspaces 中更改表的容量模式](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md) + [为 Amazon Keyspaces 中的表配置预热](warm-throughput.md) # 配置按需容量模式 Amazon Keyspaces（Apache Cassandra 兼容）*按需*容量模式是一个灵活的计费选项，可以每秒处理数千个请求而不需要进行容量规划。此选项为读取和写入请求提供 pay-per-request定价，因此您只需为实际用量付费。 选择按需模式时，Amazon Keyspaces 可以将表的吞吐容量立即扩展到以前达到的任何流量级别，然后在应用程序流量减少时调整回来。如果工作负载的流量级别达到新的峰值，则该服务会迅速调整以便为您的表增加吞吐容量。您可以为新表和现有表启用按需容量模式。 如果满足以下任意条件，则按需模式是很好的选项： + 您创建工作负载未知的新表。 + 您的应用程序流量不可预测。 + 您更喜欢只为您使用的容量付费的便利性。 要开始使用按需模式，您可以使用控制台或使用几行 Cassandra 查询语言 (CQL) 代码创建新表或更新现有表以使用按需容量模式。有关更多信息，请参阅 [表](cql.ddl.table.md)。 **Topics** + [读取请求单位和写入请求单位](#ReadWriteCapacityMode.requests) + [峰值流量和扩缩属性](#ReadWriteCapacityMode.PeakTraffic) + [按需容量模式的最初吞吐量](#ReadWriteCapacityMode.InitialThroughput) ## 读取请求单位和写入请求单位 使用按需容量模式表，您无需预先指定您希望应用程序使用多少读取和写入吞吐量。Amazon Keyspaces 按读取请求单位 () 和写入请求单位 (RRUs) 向您收取您在表上执行的读取和写入操作的费用。WRUs + 对于大小不超过 4 KB 的行，一个 *RRU* 代表一个 `LOCAL_QUORUM` 读取请求，或两个 ` LOCAL_ONE` 读取请求。如果您需要读取大于 4 KB 的行，则读取操作会使用额外的 RRUs。 RRUs 所需的总数取决于行大小，以及您是要使用一致性`LOCAL_QUORUM`还是`LOCAL_ONE`读取一致性。例如， RRUs 使用读取一致性读取 8 KB 的行需要 2 个，如果您选择`LOCAL_QUORUM``LOCAL_ONE`读取一致性，则需要 1 个 RRU。 + 一个 *WRU* 代表对大小不超过 1 KB 的行的一次写入。所有写入操作都使用`LOCAL_QUORUM`一致性，使用轻量级事务 (LWTs) 不收取额外费用。如果您需要写入大于 1 KB 的行，则写入操作会使用额外的 WRUs。 WRUs 所需的总数取决于行大小。例如，如果您的行大小为 2 KB，则需要有 2 KB WRUs 才能执行一个写入请求。 有关支持的一致性级别的信息，请参阅[支持的 Apache Cassandra 读写一致性级别和相关成本](consistency.md)。 ## 峰值流量和扩缩属性 使用按需容量模式的 Amazon Keyspaces 表会自动适应应用程序的流量。按需容量模式会即时在表中承受之前双倍的峰值流量。例如，您的应用程序流量模式可能在每秒 5,000 到 10,000 次 `LOCAL_QUORUM` 读取之间变化，其中每秒 10,000 次读取是以前的流量峰值。 使用这种模式，按需容量模式可即时容纳最高每秒 20,000 次读取的持续流量。如果应用程序承受每秒 20,000 次读取的流量，则该峰值将成为新的之前峰值，从而使后续流量高达每秒 40,000 次读取。 如果您在一个表上需要的流量是前一个峰值的两倍以上，则随着流量的增加，Amazon Keyspaces 会自动分配更多容量。这有助于确保您的表具有足够的吞吐容量来处理额外的请求。但是，如果您在 30 分钟内超过前一个峰值的两倍，则可能会出现吞吐容量不足错误。 例如，假设您的应用程序流量模式在每秒 5,000 到 10,000 个强一致性读取之间变化，而上一次达到的流量峰值为每秒 20,000 次读取。在这种情况下，服务建议您在将流量推动到每秒 40,000 次读取之前，至少将流量增长的时间间隔 30 分钟。 要了解如何估算表的读取和写入容量消耗，请参阅[估算 Amazon Keyspaces 中读取和写入吞吐量的容量消耗](capacity-examples.md)。 要了解有关账户的默认配额以及如何增加此配额的更多信息，请参阅 [Amazon Keyspaces（Apache Cassandra 兼容）限额](quotas.md)。 ## 按需容量模式的最初吞吐量 如果您在启用按需容量模式的情况下创建了新表，或者首次将现有表切换为按需容量模式，则该表将具有以下之前峰值设置，即使该表之前尚未使用按需容量模式提供流量也是如此。 + **新创建的按需容量模式表：**之前的峰值分别为 2,000 WRUs 和 6,000 RRUs。您可以立即将以前的峰值翻倍。这样做可以使新创建的按需表最多可容纳 4,000 WRUs 和 12,000 个 RRUs。 + **现有表切换到按需容量模式：**之前的峰值是前一个峰值的一半， WCUs 并且是为该表或新创建的具有按需容量模式的表的设置进行 RCUs 预配置，以较高者为准。 # 配置预置容量模式 如果您选择*预置的吞吐容量* 模式，则指定您的应用程序需要的每秒读取和写入次数。这可以帮助您管理 Amazon Keyspaces 的使用情况，使其保持在或低于定义的请求速率，从而保持可预测性。要详细了解预置吞吐量的自动扩展，请参阅[使用 Amazon Keyspaces 自动扩缩自动管理吞吐能力](autoscaling.md)。 如果满足以下任意条件，则预置的吞吐容量模式是很好的选项： + 您具有可预测的应用程序流量。 + 您​运行流量比较稳定或逐渐增加的应用程序。 + 您可以预测容量需求。 ## 读取容量单位和写入容量单位 对于预置吞吐量容量模式表，您可以根据读取容量单位 (RCUs) 和写入容量单位 () 来指定吞吐容量：WCUs + 对于大小不超过 4 KB 的行，一个 *RCU* 表示每秒一个 `LOCAL_QUORUM` 读取操作或每秒两个 `LOCAL_ONE` 读取操作。如果您需要读取大于 4 KB 的行，则读取操作会使用额外的 RCUs。 RCUs 所需的总数取决于行大小以及您想要`LOCAL_QUORUM`还是`LOCAL_ONE`读取。例如，如果您的行大小为 8 KB，则需要 2 RCUs 才能维持每秒`LOCAL_QUORUM`读取一次；如果您选择`LOCAL_ONE`读取，则需要 1 个 RCU。 + 一个 *WCU* 表示每秒对大小不超过 1 KB 的行执行一次写入操作。所有写入操作都使用`LOCAL_QUORUM`一致性，使用轻量级事务 (LWTs) 不收取额外费用。如果您需要写入大于 1 KB 的行，则写入操作会使用额外的 WCUs。 WCUs 所需的总数取决于行大小。例如，如果您的行大小为 2 KB，则需要 2 WCUs 才能维持每秒一个写入请求。有关如何估算表的读取和写入容量消耗的更多信息，请参阅[估算 Amazon Keyspaces 中读取和写入吞吐量的容量消耗](capacity-examples.md)。 如果您的应用程序读取或写入较大的行（最大为 1 MB 的 Amazon Keyspaces 行大小上限），它将消耗更多的容量单位。要了解有关如何估算行大小的更多信息，请参阅 [估算 Amazon Keyspaces 中的行大小](calculating-row-size.md)。例如，假设您创建了一个包含 6 RCUs 和 6 WCUs 的预配置表。使用这些设置，您的应用程序可以执行以下操作： + 执行高达每秒 24 KB (4 KB × 6 RCUs) 的`LOCAL_QUORUM`读取。 + 执行最高每秒 48 KB 的 `LOCAL_ONE` 读取（读取吞吐量的两倍）。 + 每秒最多写入 6 KB（1 KB × 6 WCUs）。 *预置的吞吐量* 是应用程序可以从表消耗的最大吞吐容量。如果您的应用程序超出了预置的吞吐容量，则可能会发现容量不足错误。 例如，读取请求如果没有足够的吞吐容量，就会出现 `Read_Timeout` 异常，并发布到 `ReadThrottleEvents` 指标。写入请求如果没有足够的吞吐容量，就会出现 `Write_Timeout` 异常，并发布到 `WriteThrottleEvents` 指标。 您可以使用 Amazon CloudWatch 监控您的预配置吞吐量和实际吞吐量指标以及容量不足事件。有关这些指标的更多信息，请参阅 [Amazon Keyspaces 指标与维度](metrics-dimensions.md)。 **注意** 由于容量不足而反复出现错误可能会导致客户端驱动程序特定的异常，例如， DataStax Java 驱动程序因出现故障。`NoHostAvailableException` 要更改表的吞吐容量设置，您可以使用 AWS 管理控制台 或使用 CQL 的 `ALTER TABLE` 语句，有关更多信息，请参阅 [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter)。 要了解有关账户的默认配额以及如何增加此配额的更多信息，请参阅 [Amazon Keyspaces（Apache Cassandra 兼容）限额](quotas.md)。 # 在 Amazon Keyspaces 中查看表的容量模式 您可以在 Amazon Keyspaces 系统键空间中查询系统表，以查看有关表的容量模式信息。您还可以查看表使用的是按需吞吐容量模式还是预置吞吐容量模式。如果表配置为预置吞吐量模式，您会看到为表预置的吞吐容量。 您也可以使用 AWS CLI 查看表的容量模式。 要更改表的预置吞吐量，请使用 [在 Amazon Keyspaces 中更改表的容量模式](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md)。 ------ #### [ Cassandra Query Language (CQL) ] **示例** ``` SELECT * from system_schema_mcs.tables where keyspace_name = 'mykeyspace' and table_name = 'mytable'; ``` 使用按需容量模式配置的表返回以下内容。 ``` { "capacity_mode":{ "last_update_to_pay_per_request_timestamp":"1579551547603", "throughput_mode":"PAY_PER_REQUEST" } } ``` 使用预置吞吐容量模式配置的表将返回以下内容。 ``` { "capacity_mode":{ "last_update_to_pay_per_request_timestamp":"1579048006000", "read_capacity_units":"5000", "throughput_mode":"PROVISIONED", "write_capacity_units":"6000" } } ``` `last_update_to_pay_per_request_timestamp` 值以毫秒为单位。 ------ #### [ CLI ] 使用查看表的吞吐容量模式 AWS CLI ``` aws keyspaces get-table --keyspace-name myKeyspace --table-name myTable ``` 对于预置容量模式下的表，此命令的输出可能类似于以下内容。 ``` "capacitySpecification": { "throughputMode": "PROVISIONED", "readCapacityUnits": 4000, "writeCapacityUnits": 2000 } ``` 而在按需模式下，表的输出类似如下内容。 ``` "capacitySpecification": { "throughputMode": "PAY_PER_REQUEST", "lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00" } ``` ------ # 在 Amazon Keyspaces 中更改表的容量模式 当您将表从预置的容量模式切换到按需容量模式时，Amazon Keyspaces 会对表和分区的结构进行若干更改。此过程可能耗时数分钟。在切换期间，您的表将提供与先前预置的 WCU 和 RCU 数量相一致的吞吐量。 当您从按需容量模式切换回预置的容量模式时，表将提供与表设置为按需容量模式时达到的先前峰值一致的吞吐量。 切换容量模式时，需要等待以下时间： + 您可以随时将按需模式下新创建的表切换到预置容量模式。但是，您只有在表创建时间戳的 24 小时之后才能将其切换回按需模式。 + 您可以随时将按需模式下的现有表切换到预置容量模式。但是，在 24 小时内，您只能将容量模式从预置模式切换到按需模式一次。 ------ #### [ Cassandra Query Language (CQL) ] **使用 CQL 更改表的吞吐能力模式** 1. 要将表的容量模式更改为 `PROVIOSIONED`，必须根据工作负载的预期峰值配置读取容量和写入容量单位数。以下语句便是一个示例。您也可以运行此语句来调整表的读取容量或写入容量单位数。 ``` ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 6000, 'write_capacity_units': 3000}}; ``` 要使用自动扩缩功能配置预置容量模式，请参阅[在现有表上配置自动扩缩](autoscaling.configureTable.md)。 1. 要将表的容量模式更改为按需模式，请将吞吐量模式设置为 `PAY_PER_REQUEST`。下面是一个示例语句。 ``` ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PAY_PER_REQUEST'}}; ``` 1. 您可以使用以下语句来确认表的容量模式。 ``` SELECT * from system_schema_mcs.tables where keyspace_name = 'catalog' and table_name = 'book_awards'; ``` 使用按需容量模式配置的表返回以下内容。 ``` { "capacity_mode":{ "last_update_to_pay_per_request_timestamp":"1727952499092", "throughput_mode":"PAY_PER_REQUEST" } } ``` `last_update_to_pay_per_request_timestamp` 值以毫秒为单位。 ------ #### [ CLI ] **使用更改表的吞吐容量模式 AWS CLI** 1. 要将表的容量模式更改为 `PROVIOSIONED`，必须根据工作负载的预期峰值配置读取容量和写入容量单位数。下面是一个命令示例。您也可以运行此命令来调整表的读取容量或写入容量单位数。 ``` aws keyspaces update-table --keyspace-name catalog --table-name book_awards \--capacity-specification throughputMode=PROVISIONED,readCapacityUnits=6000,writeCapacityUnits=3000 ``` 要使用自动扩缩功能配置预置容量模式，请参阅[在现有表上配置自动扩缩](autoscaling.configureTable.md)。 1. 要将表的容量模式更改为按需模式，请将吞吐量模式设置为 `PAY_PER_REQUEST`。下面是一个示例语句。 ``` aws keyspaces update-table --keyspace-name catalog --table-name book_awards \--capacity-specification throughputMode=PAY_PER_REQUEST ``` 1. 您可以使用以下命令查看为表配置的容量模式。 ``` aws keyspaces get-table --keyspace-name catalog --table-name book_awards ``` 而在按需模式下，表的输出类似如下内容。 ``` "capacitySpecification": { "throughputMode": "PAY_PER_REQUEST", "lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00" } ``` ------ # 为 Amazon Keyspaces 中的表配置预热 Amazon Keyspaces 会根据按需或预配置的吞吐量自动扩展存储分区，但是对于新表或突然出现的吞吐量峰值，分配所需的存储分区可能需要更长的时间。为确保新表或现有表具有足够的容量来支持预期的峰值吞吐量，您可以手动设置特定的*热吞吐量*值来*预热*表。 *热吞吐量*是指您的 Amazon Keyspaces 表可以立即支持的读取和写入操作的数量。默认情况下，这些值适用于所有新建和现有表。如果您使用的是按需模式，或者如果您更新了预配置吞吐量，Amazon Keyspaces 可确保您的应用程序能够立即发出不超过这些值的请求。 随着使用量的增加，Amazon Keyspaces 会自动调整温吞吐量值。要调整即将到来的高峰事件的吞吐容量，例如，当您从另一个数据库迁移数据时（可能需要在短时间内加载数 TB 的数据），您可以手动增加表的热吞吐量值。这对于请求速率可能增加 10 倍、100 倍或更高的计划峰值事件非常有用。首先，评估当前的热吞吐量是否足以处理预期的流量。然后，如果您需要为计划的峰值工作负载预热表，则可以在不更改吞吐量设置或[容量模式](ReadWriteCapacityMode.md)的情况下手动增加热吞吐量值。 您可以预热表以进行读取操作、写入操作或两者兼而有之。您可以为新的和现有的单区域表和多区域表增加此值，并且您设置的热吞吐量设置会自动应用于多区域表的所有副本。您可以随时预热的 Amazon Keyspaces 表的数量没有限制。完成预热的时间取决于您设置的值和桌子的大小。您可以同时提交预热请求，这些请求不会干扰任何表操作。您可以将桌子预热到该地区账户的桌子配额上限。使用 S [ervice Quotas 控制台](https://console.aws.amazon.com/servicequotas)检查您当前的配额，并在需要时增加配额。 默认情况下，Amazon Keyspaces 根据您的按需使用量或预配置容量调整的温吞吐量值适用于所有表，无需支付额外费用。但是，如果您手动将预热吞吐量值增加到流量峰值事件的预热表，则需要支付额外费用。有关更多信息，请参阅 [Amazon Keyspaces](https://aws.amazon.com/keyspaces/pricing/) 定价。 以下是您在预热 Amazon Keyspaces 表时可以考虑的一些不同的场景和最佳实践。 ## 热吞吐量和不均匀的访问模式 表的热吞吐量可能为每秒 30,000 个读取单位和每秒 10,000 个写入单元，但在达到这些值之前，读取或写入时仍可能遇到容量超出的事件。这可能是由于热分区造成的。虽然 Amazon Keyspaces 可以不断扩展以支持几乎无限的吞吐量，但每个分区限制为每秒 1,000 个写入单元和每秒 3,000 个读取单元。如果您的应用程序将过多的流量带到表的一小部分分区，则甚至在您达到表的热吞吐量值之前，就可能发生容量超出事件。我们建议遵循 [Amazon Keyspaces 最佳实践](bp-partition-key-design.md)，以确保无缝扩展并避免过热分区。 ## 预置表的热吞吐量 假设一个预配置表，它的热吞吐量为每秒 30,000 个读取单元和 10,000 个写入单元/秒，但目前的预配置吞吐量分别为 4,000 RCUs 和 8,000。 WCUs通过更新预配置吞吐量设置，您可以立即将表的预配置吞吐量扩展到 30,000 RCUs 或 10,000 WCUs 。当您将预配置吞吐量增加到这些值之外时，由于您已经建立了新的峰值吞吐量，因此热吞吐量会自动调整到新的更高值。例如，如果您将预配置吞吐量设置为 50,000 RCU，则热吞吐量将增加到每秒 50,000 个读取单位。 ``` "ProvisionedThroughput": { "ReadCapacityUnits": 4000, "WriteCapacityUnits": 8000 } "WarmThroughput": { "ReadUnitsPerSecond": 30000, "WriteUnitsPerSecond": 10000 } ``` ## 按需表的热吞吐量 新的按需表将以每秒 12000 个读取单位和每秒 4000 个写入单位的热吞吐量开始。表可以立即容纳高达这些级别的持续流量。当您的请求超过每秒 12,000 个读取单位或每秒 4,000 个写入单位时，热吞吐量会自动调整为更高的值。 ``` "WarmThroughput": { "ReadUnitsPerSecond": 12000, "WriteUnitsPerSecond": 4000 } ``` ## 预热 Amazon Keyspaces 表的最佳实践 在为 Amazon Keyspaces 表实施预热时，请遵循以下最佳实践： 准确估计所需的容量 由于预热会产生一次性成本，因此请根据预期的工作负载仔细计算所需的吞吐量，以避免过度配置。 考虑表的架构 行数较大的表可能需要更多的分区才能实现相同的吞吐量。在估算预热需求时，请考虑您的平均行长。 监控表性能 预热后，使用 CloudWatch 指标来验证您的表是否按预期处理负载。有关更多信息，请参阅 [使用 Amazon 监控预热桌子的性能 CloudWatch](monitor-prewarming-cloudwatch.md)。 管理配额 如果您的应用程序需要的吞吐量高于默认配额允许的吞吐量（40,000 RCUs/WCUs 或 2,000 个分区），则请求配额会在高流量事件发生之前提前增加。要请求增加配额，您可以使用 [服务限额控制台](https://console.aws.amazon.com/servicequotas)。 优化成本 对于临时的高流量事件，请考虑使用预热而不是切换到高容量的预配置模式，因为对于短时事件，这可能更具成本效益。有关定价的更多信息，请参阅 [Amazon Keyspaces](https://aws.amazon.com/keyspaces/pricing/) 定价。 **注意** 在测试阶段监控应用程序的性能指标，以验证预热配置是否足以支持您的工作负载需求。 **Topics** + [热吞吐量和不均匀的访问模式](#warm-throughput-scenarios-uneven) + [预置表的热吞吐量](#warm-throughput-scenarios-provisioned) + [按需表的热吞吐量](#warm-throughput-scenarios-ondemand) + [预热 Amazon Keyspaces 表的最佳实践](#prewarming-best-practices) + [创建具有更高热吞吐量的新 Amazon Keyspaces 表](create-table-warm-throughput.md) + [增加现有 Amazon Keyspaces 表的热吞吐量](update-warm-throughput.md) + [查看 Amazon Keyspaces 表的热吞吐量](view-warm-throughput.md) + [使用 Amazon 监控预热桌子的性能 CloudWatch](monitor-prewarming-cloudwatch.md) # 创建具有更高热吞吐量的新 Amazon Keyspaces 表 在创建 Amazon Keyspaces 表时，您可以使用控制台、CQL 或调整热吞吐量值。 AWS CLI ------ #### [ Console ] **如何使用热吞吐量设置创建新表** 1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home) 1. 在导航窗格中，选择**表**，然后选择**创建表**。 1. 在**创建表**页面的**表详细信息**部分中，选择一个键空间并为新表提供一个名称。 1. 在**列**部分，为您的表创建架构。 1. 在**主键**部分中，定义表的主键并选择可选的集群列。 1. 在**表设置**部分，选择**自定义设置**。 1. 继续**读取/写入容量设置**。 1. 对于**容量模式**，您可以选择**按需**或**预配置。** 1. 在**表格的预热**部分中，您可以根据需要增加每秒**读取单位数和每秒****写入单位数**的值，以准备表处理计划的峰值事件。 默认情况下，Amazon Keyspaces 根据您的按需使用量或预配置容量调整的温吞吐量值适用于所有表，无需支付额外费用。请注意，如果您手动增加默认的热吞吐量值以预热流量高峰事件，则需要支付额外费用。 1. 根据需要配置其他可选表格功能。然后选择 “**创建表**”。 ------ #### [ Cassandra Query Language (CQL) ] + 使用以下方法之一创建具有温吞吐量的表： + 对于预配置模式，使用以下 CQL 语法创建表并指定读取和写入的预期峰值容量： ``` CREATE TABLE catalog.book_awards ( year int, award text, rank int, category text, book_title text, author text, publisher text, PRIMARY KEY ((year, award), category, rank)) WITH CUSTOM_PROPERTIES = { 'capacity_mode': { 'throughput_mode': 'PROVISIONED', 'read_capacity_units': 20000, 'write_capacity_units': 10000 }, 'warm_throughput': { 'read_units_per_second': 40000, 'write_units_per_second': 20000 } }; ``` + 对于按需模式，使用以下 CQL 语法创建表并指定读取和写入的预期峰值容量： ``` CREATE TABLE catalog.book_awards ( year int, award text, rank int, category text, book_title text, author text, publisher text, PRIMARY KEY ((year, award), category, rank)) WITH CUSTOM_PROPERTIES = { 'capacity_mode': { 'throughput_mode': 'PAY_PER_REQUEST' }, 'warm_throughput': { 'read_units_per_second': 40000, 'write_units_per_second': 20000 } }; ``` 要确认表的容量设置，请参阅[查看 Amazon Keyspaces 表的热吞吐量](view-warm-throughput.md)。 ------ #### [ CLI ] 1. 使用以下方法之一创建具有温吞吐量的表 AWS CLI + 在预置模式下创建新表，并指定新表的预期读取和写入容量峰值。下面是一个示例语句。 ``` aws keyspaces create-table \ --keyspace-name 'catalog' \ --table-name 'book_awards' \ --schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},{name=category,type=text},{name=book_title,type=text},{name=author,type=text},{name=publisher,type=text}],partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]' \ --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=20000,writeCapacityUnits=10000 \ --warm-throughput-specification readUnitsPerSecond=40000,writeUnitsPerSecond=20000 ``` + 在按需模式下创建新表，并为新表指定读取和写入的预期峰值容量值。下面是一个示例语句。 ``` aws keyspaces create-table \ --keyspace-name 'catalog' \ --table-name 'book_awards' \ --schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},{name=category,type=text},{name=book_title,type=text},{name=author,type=text},{name=publisher,type=text}],partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]' \ --warmThroughputSpecification readUnitsPerSecond=40000,writeUnitsPerSecond=20000 ``` 1. 命令的输出返回表的 ARN，如下例所示。 ``` { "resourceArn": "arn:aws::cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards>" } ``` 要确认表的容量设置，请参阅[查看 Amazon Keyspaces 表的热吞吐量](view-warm-throughput.md)。 ------ #### [ Java ] **使用适用于 Java 的 SDK 创建新表。** + 在预置模式下创建新表，并指定新表的预期读取和写入容量峰值。以下代码示例就是这方面的一个示例。 ``` import software.amazon.awssdk.services.keyspaces.KeyspacesClient; import software.amazon.awssdk.services.keyspaces.model.*; public class PreWarmingExample { public static void main(String[] args) { KeyspacesClient keyspacesClient = KeyspacesClient.builder().build(); // Define schema List columns = Arrays.asList( ColumnDefinition.builder().name("year").type("int").build(), ColumnDefinition.builder().name("award").type("text").build(), ColumnDefinition.builder().name("rank").type("int").build(), ColumnDefinition.builder().name("category").type("text").build(), ColumnDefinition.builder().name("book_title").type("text").build(), ColumnDefinition.builder().name("author").type("text").build(), ColumnDefinition.builder().name("publisher").type("text").build() ); List partitionKeys = Arrays.asList( PartitionKey.builder().name("year").build(), PartitionKey.builder().name("award").build() ); List clusteringKeys = Arrays.asList( ClusteringKey.builder().name("category").orderBy("ASC").build(), ClusteringKey.builder().name("rank").orderBy("ASC").build() ); SchemaDefinition schema = SchemaDefinition.builder() .allColumns(columns) .partitionKeys(partitionKeys) .clusteringKeys(clusteringKeys) .build(); // Define capacity specification CapacitySpecification capacitySpec = CapacitySpecification.builder() .throughputMode(ThroughputMode.PROVISIONED) .readCapacityUnits(20000) .writeCapacityUnits(10000) .build(); // Define warm throughput specification WarmThroughputSpecification warmThroughput = WarmThroughputSpecification.builder() .readUnitsPerSecond(40000L) .writeUnitsPerSecond(20000L) .build(); // Create table with PreWarming CreateTableRequest request = CreateTableRequest.builder() .keyspaceName("catalog") .tableName("book_awards") .schemaDefinition(schema) .capacitySpecification(capacitySpec) .warmThroughputSpecification(warmThroughput) .build(); CreateTableResponse response = keyspacesClient.createTable(request); System.out.println("Table created with ARN: " + response.resourceArn()); } } ``` ------ # 增加现有 Amazon Keyspaces 表的热吞吐量 您可以使用控制台、CQL 或来增加 Amazon Keyspaces 表的当前热吞吐量值。 AWS CLI ------ #### [ Console ] **如何使用控制台增加桌子的预热设置** 1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home) 1. 在导航窗格中，选择**表**，然后选择要更新的表。 1. 在表格的 “**容量**” 选项卡上，继续对**表格进行预热。** 1. 在 “**表格的预热**” 部分中，选择 “**编辑”**。 1. 在 **“编辑表格的预热**” 页面上，您可以更新每秒**读取单位数和每秒****写入单位数**的值。 1. 选择**保存更改**。您的桌子正在使用指定的预热设置进行更新。 ------ #### [ Cassandra Query Language (CQL) ] **使用 CQL 增加表的热吞吐量设置** + 使用`ALTER TABLE`语句来增加表的热吞吐量。下面是一个示例语句。 ``` ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES = { 'warm_throughput': { 'read_units_per_second': 60000, 'write_units_per_second': 30000 } }; ``` 要确认表中更新的容量设置，请参阅[查看 Amazon Keyspaces 表的热吞吐量](view-warm-throughput.md)。 ------ #### [ CLI ] **使用增加桌子的预热设置 AWS CLI** + 要增加表格的热吞吐量，可以使用命令。`update-table`下面是一个示例语句。 ``` aws keyspaces update-table \ --keyspace-name 'catalog' \ --table-name 'book_awards' \ --warmThroughputSpecification readUnitsPerSecond=60000,writeUnitsPerSecond=30000 ``` 要确认表中更新的容量设置，请参阅[查看 Amazon Keyspaces 表的热吞吐量](view-warm-throughput.md)。 ------ #### [ Java ] **使用适用于 Java 的 SDK 更新表格的预热设置。** + 更新表的热吞吐量设置。以下代码示例就是这方面的一个示例。 ``` import software.amazon.awssdk.services.keyspaces.KeyspacesClient; import software.amazon.awssdk.services.keyspaces.model.*; public class UpdatePreWarmingExample { public static void main(String[] args) { KeyspacesClient keyspacesClient = KeyspacesClient.builder().build(); // Define new warm throughput specification WarmThroughputSpecification warmThroughput = WarmThroughputSpecification.builder() .readUnitsPerSecond(60000L) .writeUnitsPerSecond(30000L) .build(); // Update table with new PreWarming settings UpdateTableRequest request = UpdateTableRequest.builder() .keyspaceName("catalog") .tableName("book_awards") .warmThroughputSpecification(warmThroughput) .build(); UpdateTableResponse response = keyspacesClient.updateTable(request); System.out.println("Table update requested: " + response.resourceArn()); } } ``` ------ # 查看 Amazon Keyspaces 表的热吞吐量 您可以使用控制台、CQL 或查看您的 Amazon Keyspaces 表的当前热吞吐量值。 AWS CLI ------ #### [ Console ] **如何使用控制台查看桌子的预热设置。** 1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home) 1. 在导航窗格中，选择**表**，然后选择要查看的表。 1. 在表格的 “**容量**” 选项卡上，继续对**表格进行预热。** ------ #### [ Cassandra Query Language (CQL) ] **使用 CQL 查看表的热吞吐量设置** + 要查看表的热吞吐量设置，可以使用以下 CQL 语句。 ``` SELECT custom_properties FROM system_schema_mcs.tables WHERE keyspace_name='catalog' and table_name='book_awards'; // Output: ... custom_properties ---------------------------------------------------------------------------------- { 'warm_throughput': { 'read_units_per_second': '40000', 'write_units_per_second': '20000', 'status': 'AVAILABLE' } } ... ``` ------ #### [ CLI ] **使用查看表的热吞吐量设置 AWS CLI** + 您可以使用`get-table`命令查看表的热吞吐量设置，如以下示例所示。 ``` aws keyspaces get-table \ --keyspace-name 'catalog' \ --table-name 'book_awards' ``` 以下显示了预配置模式下单区域表的`get-table`命令输出示例。 ``` { "keyspaceName": "catalog", "tableName": "book_awards", ... Existing Fields ..., "capacitySpecificationSummary": { "throughputMode": "PROVISIONED", "readCapacityUnits": 20000, "writeCapacityUnits": 10000 }, "warmThroughputSpecificationSummary": { "readUnitsPerSecond": 40000, "writeUnitsPerSecond": 20000, "status": "AVAILABLE" } } ``` 以下显示了按需模式下单区域表的输出示例。 ``` { "keyspaceName": "catalog", "tableName": "book_awards_ondemand", ... Existing Fields ..., "capacitySpecification": { "throughputMode": "PAY_PER_REQUEST" }, "warmThroughputSpecificationSummary": { "readUnitsPerSecond": 40000, "writeUnitsPerSecond": 20000, "status": "AVAILABLE" } } ``` ------ #### [ Java ] **使用适用于 Java 的 SDK 读取表格的预热设置。** + 使用读取表的热吞吐量值。`get-table`以下代码示例就是这方面的一个示例。 ``` import software.amazon.awssdk.services.keyspaces.KeyspacesClient; import software.amazon.awssdk.services.keyspaces.model.*; public class GetTableWithPreWarmingExample { public static void main(String[] args) { KeyspacesClient keyspacesClient = KeyspacesClient.builder().build(); // Get table details including PreWarming specification GetTableRequest request = GetTableRequest.builder() .keyspaceName("catalog") .tableName("book_awards") .build(); GetTableResponse response = keyspacesClient.getTable(request); // Access PreWarming details if (response.warmThroughputSpecification() != null) { WarmThroughputSpecificationSummary warmThroughputSummary = response.warmThroughputSpecification(); System.out.println("PreWarming Status: " + warmThroughputSummary.status()); System.out.println("Read Units: " + warmThroughputSummary.readUnitsPerSecond()); System.out.println("Write Units: " + warmThroughputSummary.writeUnitsPerSecond()); // Check if PreWarming is active if (warmThroughputSummary.status().equals("AVAILABLE")) { System.out.println("Table is fully pre-warmed and ready for high throughput"); } else if (warmThroughputSummary.status().equals("UPDATING")) { System.out.println("Table PreWarming is currently being updated"); } } else { System.out.println("Table does not have PreWarming enabled"); } } } ``` ------ # 使用 Amazon 监控预热桌子的性能 CloudWatch Amazon Keyspaces 预热不会引入新的 CloudWatch 指标，但您可以使用现有的 Amazon Keyspaces 指标来监控预热表的性能： SuccessfulRequestLatency 监控此指标以验证预热后的表是否正在处理具有预期延迟的请求。 WriteThrottleEvents 和 ReadThrottleEvents 对于经过适当预热的桌子，这些指标应保持在较低水平。如果在预热后仍出现容量不足错误，则可能需要调整热吞吐量值。 ConsumedReadCapacityUnits 和 ConsumedWriteCapacityUnits 这些指标显示了实际的容量消耗，这有助于验证预热配置是否合适。 ProvisionedReadCapacityUnits 和 ProvisionedWriteCapacityUnits 对于已配置的表，这些指标显示当前分配的容量。 这些指标可以在 CloudWatch 控制台中查看，也可以使用 CloudWatch API 进行查询。有关更多信息，请参阅 [使用亚马逊监控亚马逊密钥空间 CloudWatch](monitoring-cloudwatch.md)。 # 使用 Amazon Keyspaces 自动扩缩自动管理吞吐能力 许多数据库工作负载本质上是周期性的，或者难以提前进行预测。例如，考虑一个大多数用户在白天处于活跃状态的社交网络应用程序。数据库必须能够处理白天活动，但夜间不需要相同级别的吞吐量。 另一个示例是面临快速采用的新移动游戏应用程序。如果此游戏变得极受欢迎，它可能会超出可用的数据库资源，从而导致性能降低并使客户感到不满。这些类型的工作负载通常需要手动干预来扩展或缩减数据库资源，以便响应不断变化的使用量级别。 Amazon Keyspaces（Apache Cassandra 兼容）可以根据实际应用程序流量自动调整吞吐容量，从而帮助您有效地为可变工作负载预置吞吐容量。Amazon Keyspaces 使用 Application Auto Scaling 服务来代表您增加或减少表的读写容量。有关 Application Auto Scaling 的更多信息，请参阅 [Application Auto Scaling 用户指南](https://docs.aws.amazon.com/autoscaling/application/userguide/)。 **注意** 要快速开始使用 Amazon Keyspaces 自动扩缩，请参阅[配置和更新 Amazon Keyspaces 自动扩缩策略](autoscaling.configure.md)。 ## Amazon Keyspaces 自动扩缩的工作原理 下图简要概述了 Amazon Keyspaces 自动扩缩如何管理表的吞吐容量。 ![\[显示用户对 Amazon Keyspaces 表进行更改时所涉及的不同服务的示意图。这些服务包括亚马逊 CloudWatch、Amazon SNS和Application Auto Scaling，后者会根据用户的读取或写入使用情况发出ALTER TABLE语句来更改容量。\]](http://docs.aws.amazon.com/zh_cn/keyspaces/latest/devguide/images/keyspaces_auto-scaling.png) 要为表启用自动扩展，请创建*扩展策略*。扩展策略指定是要扩展读取容量还是写入容量（或二者），并为表指定最小的和最大的预置容量单位设置。 扩展策略还定义了 *目标利用率*。目标利用率是在某个时间点使用的容量单位与预置容量单位的比率（以百分比表示）。自动扩展使用*目标跟踪* 算法向上或向下调整表的预置吞吐量以响应实际工作负载。这样做的目的是使实际容量利用率保持在目标利用率或接近目标利用率。 您可以为读取和写入容量设置介于 20% 和 90% 之间的自动扩展目标利用率值。默认的目标利用率为 70%。如果您的流量快速变化，并且您希望容量能够尽快开始扩展，则可以将目标利用率设置为较低的百分比。如果您的应用程序流量变化较慢，并且您希望降低吞吐量成本，则也可以将目标利用率设置为较高的百分比。 有关自动扩缩策略的更多信息，请参阅 [Application Auto Scaling 用户指南](https://docs.aws.amazon.com/autoscaling/application/userguide/)**中的 [Target tracking scaling policies for Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html)。 当您创建扩展策略时，Amazon Keyspaces 会代表您创建两对亚马逊 CloudWatch 警报。每对警报均表示预置和使用的吞吐量设置的上限和下限。当表的实际利用率持续偏离目标利用率时，就会触发这些 CloudWatch 警报。要了解有关亚马逊的更多信息 CloudWatch，请参阅[亚马逊 CloudWatch 用户指南](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)。 当其中一个 CloudWatch 警报被触发时，亚马逊简单通知服务 (Amazon SNS) Service 会向您发送通知（如果您已启用）。然后， CloudWatch 警报会调用 Application Auto Scaling 来评估您的扩展策略。这进而会向 Amazon Keyspaces 发出 Alter Table 请求，以便根据情况增加或减少表的预置容量。要了解有关 Amazon SNS 通知的更多信息，请参阅[设置 Amazon SNS 通知](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/US_SetupSNS.html)。 Amazon Keyspaces 会处理 Alter Table 请求，方式是动态增加（或减少）表的预置吞吐容量，使它接近目标利用率。 **注意** 仅当实际工作负载持续数分钟保持提高（或降低）时，Amazon Keyspaces 自动扩缩才会修改预置吞吐量设置。 目标跟踪算法寻求使目标使用率长期达到或接近选定值。表的内置容量暴增将容纳活动的短时间突增峰值。 ## 多区域表的自动扩缩工作原理 为确保在预配置容量模式下所有多区域表中的所有 AWS 区域 表副本始终有足够的读取和写入容量，我们建议您配置 Amazon Keyspaces 自动扩展。 在预置模式下使用启用自动扩缩的多区域表时，您无法为单个表副本禁用自动扩缩。但是您可以针对不同区域调整表的读取自动扩缩设置。例如，您可以针对复制了该表的每个区域，指定不同的读取容量和读取自动扩缩设置。 您为指定区域中的表副本配置的读取自动扩缩设置会覆盖该表的常规自动扩缩设置。但是，写入容量必须在所有表副本之间保持同步，以确保有足够的容量在所有区域中复制写入。 Amazon Keyspaces 自动扩缩会根据每个 AWS 区域 中的使用情况，独立更新该区域中的表的预置容量。因此，当自动扩缩处于活动状态时，每个区域中多区域表的预置容量可能会有所不同。 您可以使用 Amazon Keyspaces 控制台、API 或 CQL 配置多区域表及其副本的自动扩展设置。 AWS CLI有关如何创建和更新多区域表的自动扩缩设置的更多信息，请参阅[在 Amazon Keyspaces 中更新多区域表的预置容量和自动扩缩设置](tables-mrr-autoscaling.md)。 **注意** 如果您对多区域表使用自动扩缩功能，则必须始终使用 Amazon Keyspaces API 操作来配置自动扩缩设置。如果您直接使用 Application Auto Scaling API 操作来配置自动缩放设置，则无法指定多区域表的。 AWS 区域 这可能会导致配置不受支持。 ## 使用说明 在开始使用 Amazon Keyspaces 自动扩缩之前，您应了解以下内容： + Amazon Keyspaces 的自动扩展功能不适用于中东（阿联酋）地区。 + Amazon Keyspaces 自动扩缩会根据您的扩缩策略在必要时增加读取容量或写入容量。所有 Amazon Keyspaces 配额仍将有效，如 [Amazon Keyspaces（Apache Cassandra 兼容）限额](quotas.md)中所述。 + Amazon Keyspaces 自动扩缩不会阻止您手动修改预置的吞吐量设置。这些手动调整不会影响附加到扩展策略的任何现有 CloudWatch 警报。 + 如果您使用控制台创建预置了吞吐容量的表，则默认情况下将启用 Amazon Keyspaces 自动扩缩。您可以随时修改自动扩展设置。有关更多信息，请参阅 [为表关闭 Amazon Keyspaces 自动扩缩](autoscaling.turnoff.md)。 + 如果您使用 CloudFormation 创建扩展策略，则应从中管理扩展策略， CloudFormation 以便堆栈与堆栈模板同步。如果您更改了 Amazon Keyspaces 的扩展策略，则在重置堆栈时，这些策略将被 CloudFormation 堆栈模板中的原始值覆盖。 + 如果您使用 CloudTrail 监控Amazon Keyspaces的自动扩展，则可能会看到Application Auto Scaling在配置验证过程中拨打的呼叫提醒。您可以使用 `invokedBy` 字段筛选掉这些警报，其中包含用于这些验证检查的 `application-autoscaling.amazonaws.com`。 # 配置和更新 Amazon Keyspaces 自动扩缩策略 您可以使用控制台、CQL 或 AWS Command Line Interface (AWS CLI) 为新表和现有表配置 Amazon Keyspaces 的自动扩展。您还可以修改自动扩缩设置或禁用自动扩缩。 要获得更高级的功能，例如设置缩减和横向扩展冷却时间，我们建议您使用 CQL 或来管理 AWS CLI Amazon Keyspaces 扩展策略。 **Topics** + [配置 Amazon Keyspaces 自动扩缩的权限](autoscaling.permissions.md) + [创建启用了自动扩缩的新表](autoscaling.createTable.md) + [在现有表上配置自动扩缩](autoscaling.configureTable.md) + [查看表的 Amazon Keyspaces 自动扩缩配置](autoscaling.viewPolicy.md) + [为表关闭 Amazon Keyspaces 自动扩缩](autoscaling.turnoff.md) + [在亚马逊中查看 Amazon Keyspaces 表的自动扩展活动 CloudWatch](autoscaling.activity.md) # 配置 Amazon Keyspaces 自动扩缩的权限 要开始使用，请确认主体具有创建和管理自动扩缩设置所需的适当权限。在 AWS Identity and Access Management (IAM) 中，需要使用 AWS 托管策略来管理 Amazon Keys `AmazonKeyspacesFullAccess` paces 扩展策略。 **重要** 需要 `application-autoscaling:*` 权限才能对表禁用自动扩展。您必须首先关闭表的自动扩缩，然后才能将其删除。 要针对 Amazon Keyspaces 控制台访问和 Amazon Keyspaces 自动扩缩设置 IAM 用户或角色，请添加以下策略。 **附加 `AmazonKeyspacesFullAccess` 策略** 1. 登录 AWS 管理控制台 并打开 IAM 控制台，网址为[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在 IAM 控制台控制面板上，选择**用户**，然后从列表中选择您的 IAM 用户或角色。 1. 在 **Summary (摘要)** 页上，选择 **Add permissions (添加权限)**。 1. 选择**直接附加现有策略**。 1. 从策略列表中选择 **AmazonKeyspacesFullAccess**，然后选择**下一步：查看**。 1. 选择**添加权限**。 # 创建启用了自动扩缩的新表 创建新的 Amazon Keyspaces 表时，您可以自动为表的写入或读取容量启用自动扩缩功能。如此，Amazon Keyspaces 便可以代表您联系 Application Auto Scaling，将该表注册为可扩展目标并调整预置的写入或读取容量。 有关如何创建多区域表以及如何为表副本配置不同的自动扩缩设置的更多信息，请参阅[在 Amazon Keyspaces 中使用自动扩缩功能在预置模式下创建多区域表](tables-mrr-create-provisioned.md)。 **注意** Amazon Keyspaces 自动扩缩需要存在一个代表您执行自动扩缩操作的服务相关角色 (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`)。将自动为您创建此角色。有关更多信息，请参阅 [对 Amazon Keyspaces 使用服务相关角色](using-service-linked-roles.md)。 ------ #### [ Console ] **使用控制台创建启用了自动扩缩功能的新表** 1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home) 1. 在导航窗格中，选择**表**，然后选择**创建表**。 1. 在**创建表**页面的**表详细信息**部分中，选择一个键空间并为新表提供一个名称。 1. 在**列**部分，为您的表创建架构。 1. 在**主键**部分中，定义表的主键并选择可选的集群列。 1. 在**表设置**部分，选择**自定义设置**。 1. 继续**读取/写入容量设置**。 1. 对于 **Capacity mode (容量模式)**，选择 **Provisioned (预置)**。 1. 在 **Read capacity (读取容量)** 部分中，确认已选择 **Scale automatically(自动扩展)**。 在此步骤中，您将选择表的最小和最大读取容量单位以及目标利用率。 + **最小容量单位**：输入表应始终支持的最小吞吐量级别的值。该值必须介于 1 和账户的每秒最大吞吐量配额（默认为 40000）之间。 + **最大容量单位**：输入要为表预置的最大吞吐量。该值必须介于 1 和账户的每秒最大吞吐量配额（默认为 40000）之间。 + **目标利用率**：输入介于 20% 和 90% 之间的目标利用率。当流量超过定义的目标利用率时，容量将自动扩展。当流量低于定义的目标时，容量将自动重新缩减。 **注意** 要了解有关账户的默认配额以及如何增加此配额的更多信息，请参阅 [Amazon Keyspaces（Apache Cassandra 兼容）限额](quotas.md)。 1. 在**写入容量**部分中，选择上一步中为读取容量定义的设置，或手动配置容量值。 1. 选择**创建表**。使用指定的自动扩展参数创建表。 ------ #### [ Cassandra Query Language (CQL) ] **使用 CQL 创建启用 Amazon Keyspaces 自动扩缩功能的新表** 要以编程方式为表配置自动扩缩设置，您可以使用包含 Amazon Keyspaces 自动扩缩参数的 `AUTOSCALING_SETTINGS` 语句。这些参数定义了指示 Amazon Keyspaces 调整表的预置吞吐量的条件，以及要采取的额外可选操作。在此示例中，您可以定义 *mytable* 的自动扩缩设置。 该策略包含以下元素： + `AUTOSCALING_SETTINGS` - 指定是否允许 Amazon Keyspaces 代表您调整吞吐能力。必需的值如下： + `provisioned_write_capacity_autoscaling_update`: + `minimum_units` + `maximum_units` + `provisioned_read_capacity_autoscaling_update`: + `minimum_units` + `maximum_units` + `scaling_policy` - Amazon Keyspaces 支持目标跟踪策略。要定义目标跟踪策略，请配置以下参数。 + `target_value` – Amazon Keyspaces 自动扩缩可确保消耗的容量与预置容量的比例保持在该值或接近该值。您将 `target_value` 定义为百分比。 + `disableScaleIn`:（可选）一个 `boolean`，指定是否为该表禁用或启用 `scale-in`。默认情况下，将禁用此参数。要开启 `scale-in`，请将 `boolean` 值设置为 `FALSE`。这表示会代表您自动缩减表的容量。 + `scale_out_cooldown` – 横向扩展活动会增加表的预置吞吐量。要为横向扩展活动增加冷却时间，请为 `scale_out_cooldown` 指定一个值（以秒为单位）。如果您不指定值，则默认值为 0。有关目标跟踪和冷却时间的更多信息，请参阅《Application Auto Scaling 用户指南》中的 [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html)。 + `scale_in_cooldown` – 横向缩减活动会减小表的预置吞吐量。要为缩减活动增加冷却时间，请为 `scale_in_cooldown` 指定一个值（以秒为单位）。如果您不指定值，则默认值为 0。有关目标跟踪和冷却时间的更多信息，请参阅《Application Auto Scaling 用户指南》中的 [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html)。 **注意** 为了进一步了解 `target_value` 的工作原理，假设您的表的预配置吞吐量设置为 200 个写入容量单位。您决定为此表创建扩展策略，并使用 `target_value` 的 70%。 现在假设您开始将写入流量驱动到表，以便实际写入吞吐量为 150 个容量单位。现在的 consumed-to-provisioned比率是（150/200），即75％。此比率超出了您的目标，因此自动扩缩会将预置写入容量增加到 215，使该比率为（150/215）或 69.77%，尽可能接近 `target_value`，但不超过该值。 对于 *mytable*，您可以将读取和写入容量的 `TargetValue` 都设置为 50%。Amazon Keyspaces 自动扩展可在 5-10 个容量单位范围内调整表的预配置吞吐量，使该 consumed-to-provisioned比率保持在或接近 50%。对于读取容量，您可以将 `ScaleOutCooldown` 和 `ScaleInCooldown` 值设置为 60 秒。 您可以使用以下语句创建启用自动扩缩功能的新 Amazon Keyspaces 表。 ``` CREATE TABLE mykeyspace.mytable(pk int, ck int, PRIMARY KEY (pk, ck)) WITH CUSTOM_PROPERTIES = { 'capacity_mode': { 'throughput_mode': 'PROVISIONED', 'read_capacity_units': 1, 'write_capacity_units': 1 } } AND AUTOSCALING_SETTINGS = { 'provisioned_write_capacity_autoscaling_update': { 'maximum_units': 10, 'minimum_units': 5, 'scaling_policy': { 'target_tracking_scaling_policy_configuration': { 'target_value': 50 } } }, 'provisioned_read_capacity_autoscaling_update': { 'maximum_units': 10, 'minimum_units': 5, 'scaling_policy': { 'target_tracking_scaling_policy_configuration': { 'target_value': 50, 'scale_in_cooldown': 60, 'scale_out_cooldown': 60 } } } }; ``` ------ #### [ CLI ] **使用 Amazon Keyspaces 自动缩放创建新表 AWS CLI** 要以编程方式为表配置自动扩缩设置，您可以使用定义 Amazon Keyspaces 自动扩缩参数的 `autoScalingSpecification` 操作。这些参数定义了指示 Amazon Keyspaces 调整表的预置吞吐量的条件，以及要采取的额外可选操作。在此示例中，您可以定义 *mytable* 的自动扩缩设置。 该策略包含以下元素： + `autoScalingSpecification` - 指定是否允许 Amazon Keyspaces 代表您调整容量吞吐量。您可以分别为读取和写入容量启用自动扩缩。然后，您必须指定 `autoScalingSpecification` 的以下参数： + `writeCapacityAutoScaling` - 最大和最小写入容量单位数。 + `readCapacityAutoScaling` - 最大和最小读取容量单位数。 + `scalingPolicy` - Amazon Keyspaces 支持目标跟踪策略。要定义目标跟踪策略，请配置以下参数。 + `targetValue` – Amazon Keyspaces 自动扩缩可确保消耗的容量与预置容量的比例保持在该值或接近该值。您将 `targetValue` 定义为百分比。 + `disableScaleIn`:（可选）一个 `boolean`，指定是否为该表禁用或启用 `scale-in`。默认情况下，将禁用此参数。要开启 `scale-in`，请将 `boolean` 值设置为 `FALSE`。这表示会代表您自动缩减表的容量。 + `scaleOutCooldown` – 横向扩展活动会增加表的预置吞吐量。要为横向扩展活动增加冷却时间，请为 `ScaleOutCooldown` 指定一个值（以秒为单位）。默认值是 0。有关目标跟踪和冷却时间的更多信息，请参阅《Application Auto Scaling 用户指南》中的 [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html)。 + `scaleInCooldown` – 横向缩减活动会减小表的预置吞吐量。要为缩减活动增加冷却时间，请为 `ScaleInCooldown` 指定一个值（以秒为单位）。默认值是 0。有关目标跟踪和冷却时间的更多信息，请参阅《Application Auto Scaling 用户指南》中的 [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html)。 **注意** 为了进一步了解 `TargetValue` 的工作原理，假设您的表的预配置吞吐量设置为 200 个写入容量单位。您决定为此表创建扩展策略，并使用 `TargetValue` 的 70%。 现在假设您开始将写入流量驱动到表，以便实际写入吞吐量为 150 个容量单位。现在的 consumed-to-provisioned比率是（150/200），即75％。此比率超出了您的目标，因此自动扩缩会将预置写入容量增加到 215，使该比率为（150/215）或 69.77%，尽可能接近 `TargetValue`，但不超过该值。 对于 *mytable*，您可以将读取和写入容量的 `TargetValue` 都设置为 50%。Amazon Keyspaces 自动扩展可在 5-10 个容量单位范围内调整表的预配置吞吐量，使该 consumed-to-provisioned比率保持在或接近 50%。对于读取容量，您可以将 `ScaleOutCooldown` 和 `ScaleInCooldown` 值设置为 60 秒。 创建具有复杂自动扩缩设置的表时，建议从 JSON 文件加载自动扩缩设置。对于下面的示例，您可以从 [auto-scaling.zip](samples/auto-scaling.zip) 下载示例 JSON 文件并提取 `auto-scaling.json`，记下文件路径。在本示例中，JSON 文件位于当前目录下。有关不同的文件路径选项，请参阅[如何从文件加载参数](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how)。 ``` aws keyspaces create-table --keyspace-name mykeyspace --table-name mytable \ --schema-definition 'allColumns=[{name=pk,type=int},{name=ck,type=int}],partitionKeys=[{name=pk},{name=ck}]' \ --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=1,writeCapacityUnits=1 \ --auto-scaling-specification file://auto-scaling.json ``` ------ # 在现有表上配置自动扩缩 您可以更新现有 Amazon Keyspaces 表，为表的写入或读取容量开启自动扩缩功能。如果您要更新当前处于按需容量模式的表，则必须先将表的容量模式更改为预置容量模式。 有关如何更新多区域表的自动扩缩设置的更多信息，请参阅[在 Amazon Keyspaces 中更新多区域表的预置容量和自动扩缩设置](tables-mrr-autoscaling.md)。 Amazon Keyspaces 自动扩缩需要存在一个代表您执行自动扩缩操作的服务相关角色 (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`)。将自动为您创建此角色。有关更多信息，请参阅 [对 Amazon Keyspaces 使用服务相关角色](using-service-linked-roles.md)。 ------ #### [ Console ] **为现有表配置 Amazon Keyspaces 自动扩缩** 1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home) 1. 选择要处理的表，然后转到**容量**选项卡。 1. 在**容量设置**部分中，选择**编辑**。 1. 在**容量模式**下，确保表使用**预置**容量模式。 1. 选择**自动扩展**，然后按照[创建启用了自动扩缩的新表](autoscaling.createTable.md)中的步骤 6 操作来编辑读取和写入容量。 1. 在定义自动扩展设置时，选择 **Save (保存)**。 ------ #### [ Cassandra Query Language (CQL) ] **使用 CQL 配置启用 Amazon Keyspaces 自动扩缩的现有表** 您可以使用现有 Amazon Keyspaces 表的 `ALTER TABLE` 语句为表的写入或读取容量配置自动扩缩。如果您要更新当前处于按需容量模式的表，则必须将 `capacity_mode` 设置为预置模式。如果您的表已经处于预置容量模式，则可以忽略此字段。 在以下示例中，该语句更新了处于按需容量模式的表 *mytable*。该语句将表的容量模式更改为启用自动扩缩的预置模式。 写入容量配置为 5 到 10 个容量单位，目标值为 50%。读取容量也配置为 5 到 10 个容量单位，目标值为 50%。对于读取容量，您可以将 `scale_out_cooldown` 和 `scale_in_cooldown` 值设置为 60 秒。 ``` ALTER TABLE mykeyspace.mytable WITH CUSTOM_PROPERTIES = { 'capacity_mode': { 'throughput_mode': 'PROVISIONED', 'read_capacity_units': 1, 'write_capacity_units': 1 } } AND AUTOSCALING_SETTINGS = { 'provisioned_write_capacity_autoscaling_update': { 'maximum_units': 10, 'minimum_units': 5, 'scaling_policy': { 'target_tracking_scaling_policy_configuration': { 'target_value': 50 } } }, 'provisioned_read_capacity_autoscaling_update': { 'maximum_units': 10, 'minimum_units': 5, 'scaling_policy': { 'target_tracking_scaling_policy_configuration': { 'target_value': 50, 'scale_in_cooldown': 60, 'scale_out_cooldown': 60 } } } }; ``` ------ #### [ CLI ] **使用 Amazon Keyspaces 自动缩放配置现有表 AWS CLI** 对于现有 Amazon Keyspaces 表，您可以使用 `UpdateTable` 操作为表的写入或读取容量开启自动扩缩功能。 您可以使用以下命令为现有表开启 Amazon Keyspaces 自动扩缩。表的自动扩缩设置从 JSON 文件加载。对于下面的示例，您可以从 [auto-scaling.zip](samples/auto-scaling.zip) 下载示例 JSON 文件并提取 `auto-scaling.json`，记下文件路径。在本示例中，JSON 文件位于当前目录下。有关不同的文件路径选项，请参阅[如何从文件加载参数](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how)。 有关以下示例中所用的自动扩缩设置的更多信息，请参阅[创建启用了自动扩缩的新表](autoscaling.createTable.md)。 ``` aws keyspaces update-table --keyspace-name mykeyspace --table-name mytable \ --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=1,writeCapacityUnits=1 \ --auto-scaling-specification file://auto-scaling.json ``` ------ # 查看表的 Amazon Keyspaces 自动扩缩配置 您可以使用控制台、CQL 或 AWS CLI 来查看和更新表的 Amazon Keyspaces 自动缩放设置。 ------ #### [ Console ] **** **使用控制台查看自动扩缩设置** 1. 选择要查看的表，然后转到**容量**选项卡。 1. 在**容量设置**部分中，选择**编辑**。现在可以修改**读取容量**或**写入容量**部分中的设置。有关这些设置的更多信息，请参阅 [创建启用了自动扩缩的新表](autoscaling.createTable.md)。 ------ #### [ Cassandra Query Language (CQL) ] **使用 CQL 查看表的 Amazon Keyspaces 自动扩缩策略** 要查看表的自动扩缩配置的详细信息，请使用以下命令。 ``` SELECT * FROM system_schema_mcs.autoscaling WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable'; ``` 该命令的输出如下所示。 ``` keyspace_name | table_name | provisioned_read_capacity_autoscaling_update | provisioned_write_capacity_autoscaling_update ---------------+------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mykeyspace | mytable | {'minimum_units': 5, 'maximum_units': 10, 'scaling_policy': {'target_tracking_scaling_policy_configuration': {'scale_out_cooldown': 60, 'disable_scale_in': false, 'target_value': 50, 'scale_in_cooldown': 60}}} | {'minimum_units': 5, 'maximum_units': 10, 'scaling_policy': {'target_tracking_scaling_policy_configuration': {'scale_out_cooldown': 0, 'disable_scale_in': false, 'target_value': 50, 'scale_in_cooldown': 0}}} ``` ------ #### [ CLI ] **使用以下命令查看您的表的 Amazon Keyspaces 自动扩展策略 AWS CLI** 要查看表的自动扩缩配置，您可以使用 `get-table-auto-scaling-settings` 操作。下面是一个 CLI 命令示例。 ``` aws keyspaces get-table-auto-scaling-settings --keyspace-name mykeyspace --table-name mytable ``` 该命令的输出如下所示。 ``` { "keyspaceName": "mykeyspace", "tableName": "mytable", "resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable", "autoScalingSpecification": { "writeCapacityAutoScaling": { "autoScalingDisabled": false, "minimumUnits": 5, "maximumUnits": 10, "scalingPolicy": { "targetTrackingScalingPolicyConfiguration": { "disableScaleIn": false, "scaleInCooldown": 0, "scaleOutCooldown": 0, "targetValue": 50.0 } } }, "readCapacityAutoScaling": { "autoScalingDisabled": false, "minimumUnits": 5, "maximumUnits": 10, "scalingPolicy": { "targetTrackingScalingPolicyConfiguration": { "disableScaleIn": false, "scaleInCooldown": 60, "scaleOutCooldown": 60, "targetValue": 50.0 } } } } } ``` ------ # 为表关闭 Amazon Keyspaces 自动扩缩 您可以随时为表关闭 Amazon Keyspaces 自动扩缩。如果不再需要扩缩表的读取或写入容量，您应考虑关闭自动扩缩策略，这样 Amazon Keyspaces 就不会继续修改表的读取或写入容量设置。您可以使用控制台、CQL 或 AWS CLI更新表。 关闭 auto scaling 也会删除以您的名义创建的 CloudWatch 警报。 要删除 Application Auto Scaling 用于访问 Amazon Keyspaces 表的服务相关角色，请按照[删除适用于 Amazon Keyspaces 的服务相关角色](using-service-linked-roles-app-auto-scaling.md#delete-service-linked-role-app-auto-scaling)中的步骤操作。 **注意** 要删除 Application Auto Scaling 使用的服务相关角色，您必须在所有 AWS 区域中禁用账户中所有表的自动扩缩。 ------ #### [ Console ] **使用控制台为表关闭 Amazon Keyspaces 自动扩缩功能** **使用 Amazon Keyspaces 控制台** 1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home) 1. 选择要更新的表，然后转到**容量**选项卡。 1. 在**容量设置**部分中，选择**编辑**。 1. 要禁用 Amazon Keyspaces 自动扩缩，请清除**自动扩展**复选框。禁用自动扩缩会在 Application Auto Scaling 中取消将表注册为可扩展目标。 ------ #### [ Cassandra Query Language (CQL) ] **使用 CQL 为表关闭 Amazon Keyspaces 自动扩缩** 以下语句可关闭表 *mytable* 写入容量的自动扩缩。 ``` ALTER TABLE mykeyspace.mytable WITH AUTOSCALING_SETTINGS = { 'provisioned_write_capacity_autoscaling_update': { 'autoscaling_disabled': true } }; ``` ------ #### [ CLI ] **使用 “关闭 Amazon Keyspaces 自动缩放表格” AWS CLI** 以下命令可关闭表读取容量的自动扩缩。它还会删除以您的名义创建的 CloudWatch 警报。 ``` aws keyspaces update-table --keyspace-name mykeyspace --table-name mytable \ --auto-scaling-specification readCapacityAutoScaling={autoScalingDisabled=true} ``` ------ # 在亚马逊中查看 Amazon Keyspaces 表的自动扩展活动 CloudWatch 您可以使用亚马逊来监控 Amazon Keyspaces 自动扩展如何使用资源 CloudWatch，亚马逊会生成有关您的使用情况和性能的指标。按照《[Application Auto Scaling 用户指南](https://docs.aws.amazon.com/autoscaling/application/userguide/monitoring-cloudwatch.html)》中的步骤创建 CloudWatch仪表板。 # 在 Amazon Keyspaces 中有效使用容量爆增 Amazon Keyspaces 提供*容量暴增*功能，为每个分区吞吐量调配提供一定的灵活性。当您未完全使用分区的吞吐量时，Amazon Keyspaces 为稍后的吞吐量*突增*情况保留一部分未使用的容量以应对用量峰值。 Amazon Keyspaces 当前保留最多五分钟（300 秒）未使用的读取和写入容量。在读取或写入活动偶尔突增期间，这些额外的容量单元会被快速消耗，甚至超过您为表定义的每秒预置的吞吐能力。 Amazon Keyspaces 还可能在不事先通知的情况下，将容量暴增用于后台维护和其他任务。 请注意，这些暴增容量详细信息未来可能发生变化。