# 使用 DynamoDB Auto Scaling 自动管理吞吐能力 许多数据库工作负载本质上是周期性的，而另一些则难以提前进行预测。例如，考虑一个大多数用户在白天处于活跃状态的社交网络应用程序。数据库必须能够处理白天活动，但夜间不需要相同级别的吞吐量。而在另一个例子中，请考虑正在经历用户快速增长的新移动游戏应用程序。如果此游戏变得太受欢迎，它可能会超出可用的数据库资源，从而导致性能降低并使客户感到不满。这些类型的工作负载通常需要手动干预来扩展或缩减数据库资源，以便响应不断变化的使用量级别。 Amazon DynamoDB Auto Scaling 使用 AWS Application Auto Scaling 服务代表您动态调整预置的吞吐容量，以响应实际的流量模式。这使表或全局二级索引（GSI）能够增大其预置的读取和写入容量来处理突发的流量增加，而不会发生节流。当工作负载减少时，Application Auto Scaling 可以减少吞吐量，这样您就无需为未使用的预置容量付费。 **注意** 如果您使用 AWS 管理控制台 创建表或全局二级索引，默认情况下将启用 DynamoDB Auto Scaling。您可以随时修改 Auto Scaling 设置。有关更多信息，请参阅 [通过 AWS 管理控制台使用 DynamoDB 自动扩缩](AutoScaling.Console.md)。 删除表或全局表副本时，任何关联的可扩展目标、扩缩策略或 CloudWatch 告警都不会随之自动删除。 使用 Application Auto Scaling，您可以创建为表或全局二级索引*扩展策略*。扩展策略指定是要扩展读取容量还是写入容量（或二者同时扩展），并为表或索引指定最小的和最大的预置容量单位设置。 扩展策略还包含*目标使用率*，某个时间点已使用的预调配吞吐量的百分比。Application Auto Scaling 使用*目标跟踪*算法来向上或向下调整表（或索引）的预调配吞吐量以响应实际工作负载，从而使实际容量使用率达到或接近您的目标使用率。 DynamoDB 输出在一分钟时段内所使用的预调配吞吐量。当所使用的容量在两个连续的一分钟时段内均超过配置的目标利用率时，就会触发自动扩缩。在触发自动扩缩之前，CloudWatch 警报可能会有至多几分钟的短暂延迟。这一延迟可确保准确评估 CloudWatch 指标。如果已使用的吞吐量峰值间隔超过一分钟，则可能不会触发自动扩缩。同样，当 15 个连续的数据点低于目标利用率时，则可能发生缩减事件。无论是哪种情况，在自动扩缩触发之后，都会调用 [UpdateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html) API。然后，需要几分钟的时间才能更新表或索引的预置容量。在此期间，任何超过表的先前预置容量的请求都会被节流。 **重要** 您无法调整要超过的数据点数量来触发底层警报（尽管当前的数值将来可能会发生变化）。 您可以为读取和写入容量设置介于 20% 和 90% 之间的 Auto Scaling 目标利用率值。 **注意** 除了表之外，DynamoDB Auto Scaling 还支持全局二级索引。每个全局二级索引均有各自的预置的吞吐容量，这独立于其基表的吞吐容量。在为全局二级索引创建扩展策略时，Application Auto Scaling 将调整索引的预调配吞吐量设置，确保其实际使用量达到或接近所需的使用率。 ## DynamoDB Auto Scaling 的工作原理 **注意** 要快速开始使用 DynamoDB Auto Scaling，请参阅 [通过 AWS 管理控制台使用 DynamoDB 自动扩缩](AutoScaling.Console.md)。 下图简要概述了 DynamoDB Auto Scaling 管理表的吞吐能力的方式。 ![\[DynamoDB Auto Scaling 会调整表的吞吐能力以满足需求。\]](http://docs.aws.amazon.com/zh_cn/amazondynamodb/latest/developerguide/images/auto-scaling.png) 以下步骤汇总了上图中所示的 Auto Scaling 流程： 1. 为 DynamoDB 表创建 Application Auto Scaling 策略。 1. DynamoDB 会将使用的容量指标发布到 Amazon CloudWatch。 1. 如果表使用的容量在特定时段内超出目标使用率 (或低于目标使用率)，则 Amazon CloudWatch 将触发警报。您可以在控制台上查看警报并使用 Amazon Simple Notification Service (Amazon SNS) 接收通知。 1. CloudWatch 警报调用 Application Auto Scaling 来评估扩展策略。 1. Application Auto Scaling 发出 `UpdateTable` 请求以调整表的预调配吞吐量。 1. DynamoDB 处理 `UpdateTable` 请求，并动态增加（或减少）表的预置的吞吐容量，使它接近目标使用率。 为了解 DynamoDB Auto Scaling 的工作方式，假定您有一个名为 `ProductCatalog` 的表。由于很少将数据批量加载到表中，因此不会出现大量写入活动。不过，表会遇到大量的读取活动，此活动随时间的推移而变化。通过监控 `ProductCatalog` 的 Amazon CloudWatch 指标，您确定表需要 1200 个读取容量单位（避免在活动到达峰值时出现 DynamoDB 限制读取请求的情况）。您还确定，在读取流量达到其最低值时，`ProductCatalog` 至少需要 150 个读取容量单位。有关防止限制的更多信息，请参阅[Amazon DynamoDB 中的节流故障排除](TroubleshootingThrottling.md)。 在 150 到 1200 个读取容量单位的范围内，您确定 70% 的目标使用率将适合 `ProductCatalog` 表。*目标利用率*是使用的容量单位与预置容量单位的比率（以百分比表示）。应用 Application Auto Scaling 使用其目标跟踪算法来确保 `ProductCatalog` 会根据需要进行调整，使利用率保持在 70% 或接近 70%。 **注意** 仅当实际工作负载在几分钟的持续时段内保持提高或降低时，DynamoDB Auto Scaling 才会修改预调配吞吐量设置。Application Auto Scaling 目标跟踪算法寻求使目标使用率长期达到或接近选定值。 表的内置容量暴增将容纳活动的短时间突增峰值。有关更多信息，请参阅 [容量爆增](burst-adaptive-capacity.md#burst-capacity)。 要为 `ProductCatalog` 表启用 DynamoDB Auto Scaling，请创建扩展策略。此策略指定以下内容： + 要管理的表或全局二级索引 + 要管理的容量类型（读取容量或写入容量） + 预配置吞吐量设置的上限和下限 + 您的目标利用率 创建扩展策略时，Application Auto Scaling 将代表您创建一对 Amazon CloudWatch 警报。每对警报均指明预调配吞吐量设置的上限和下限。当表的实际使用率在一段持续时间内偏离目标使用率时，将触发这些 CloudWatch 警报。 当触发某个 CloudWatch 警报时，Amazon SNS 将向您发送通知（如果您已启用通知）。随后，CloudWatch 警报将调用 Application Auto Scaling，后者随之通知 DynamoDB 视情况向上或向下调整 `ProductCatalog` 表的预配置容量。 在扩展事件发生期间，AWS Config 按记录的配置项目进行收费。发生扩展事件时，会为每个读取和写入自动扩缩事件创建四个 CloudWatch 警报，即两个 ProvisionedCapacity 警报（ProvisionedCapacityLow、ProvisionedCapacityHigh）和两个 ConsumedCapacity 警报（AlarmHigh、AlarmLow）。这会导致总共创建八个警报。因此，AWS Config 为每个扩展事件记录八个配置项目。 **注意** 您还可以安排 DynamoDB 扩展，使其在特定时间进行。点击[此处](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html)了解基本步骤。 ## 使用说明 在开始使用 DynamoDB Auto Scaling 之前，您应了解以下内容： + DynamoDB Auto Scaling 会根据您的自动扩缩策略增加读取容量或写入容量任意次数。所有 DynamoDB 配额都将保持有效，如 [Amazon DynamoDB 中的配额](ServiceQuotas.md) 中所述。 + DynamoDB Auto Scaling 不会阻止您手动修改预置的吞吐量设置。这些手动调整不会影响与 DynamoDB Auto Scaling 相关的任何现有 CloudWatch 警报。 + 如果您为包含一个或多个全局二级索引的表启用 DynamoDB Auto Scaling，强烈建议您也对这些索引统一应用自动扩缩。这将有助于确保更好的表写入和读取性能，并帮助避免节流。您可以在 AWS 管理控制台 中选择**将相同设置应用到全局二级索引**来启用自动扩缩。有关更多信息，请参阅 [在现有表上启用 DynamoDB 自动扩缩](AutoScaling.Console.md#AutoScaling.Console.ExistingTable)。 + 删除表或全局表副本时，任何关联的可扩展目标、扩缩策略或 CloudWatch 告警都不会随之自动删除。 + 为现有表创建 GSI 时，系统不会为 GSI 启用自动扩缩。在构建 GSI 时，您必须手动管理容量。GSI 上的回填完成并到达活动状态后，自动扩缩操作将正常运行。 # 通过 AWS 管理控制台使用 DynamoDB 自动扩缩 如果您使用 AWS 管理控制台 创建表或，默认情况下将启用 Amazon DynamoDB 自动扩缩。您还可以使用控制台为现有表启用自动扩缩、修改自动扩缩设置或禁用自动扩缩。 **注意** 对于设置缩减和扩展冷却时间等更高级的功能，请使用 AWS Command Line Interface (AWS CLI) 通过编程方式管理 DynamoDB 自动扩缩。有关更多信息，请参阅 [使用 AWS CLI 管理 DynamoDB 自动扩缩](AutoScaling.CLI.md)。 **Topics** + [开始之前：向用户授予 DynamoDB 自动扩缩的权限](#AutoScaling.Permissions) + [创建启用了自动扩缩的新表](#AutoScaling.Console.NewTable) + [在现有表上启用 DynamoDB 自动扩缩](#AutoScaling.Console.ExistingTable) + [在控制台上查看自动扩缩活动](#AutoScaling.Console.ViewingActivities) + [修改或禁用 DynamoDB 自动扩缩设置](#AutoScaling.Console.Modifying) ## 开始之前：向用户授予 DynamoDB 自动扩缩的权限 在 AWS Identity and Access Management（IAM）中，AWS 托管策略 `DynamoDBFullAccess` 提供使用 DynamoDB 控制台所需的权限。但是，对于 DynamoDB 自动扩缩，用户需要额外的权限。 **重要** 要删除启用自动扩缩的表，需要 `application-autoscaling:*` 权限。AWS 托管策略 `DynamoDBFullAccess` 包含此类权限。 要设置用户来执行 DynamoDB 控制台访问和 DynamoDB 自动扩缩操作，请创建一个角色并向该角色添加 **AmazonDynamoDBFullAccess** 策略。然后，将该角色分配给用户。 ## 创建启用了自动扩缩的新表 **注意** DynamoDB Auto Scaling 功能需要存在一个代表您执行自动扩缩操作的服务相关角色（`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`）。将自动为您创建此角色。有关更多信息，请参阅《应用程序自动扩缩用户指南》**中的[实现应用程序自动扩缩的服务相关角色](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html)。 **创建启用了自动扩缩的新表** 1. 打开 DynamoDB 控制台：[https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)。 1. 选择**创建表**。 1. 在**创建表**页面上，输入**表名称**和主键详细信息。 1. 如果您选择**默认设置**，则会在新表中启用自动扩缩。 否则，请选择**自定义设置**，并执行以下操作来指定表的自定义设置： 1. 对于**表类**，请保留默认选择 **DynamoDB 标准**。 1. 对于**读/写容量设置**，请保留默认选择**已预置**，然后执行以下操作： 1. 对于**读取容量**，请确保将**自动扩缩**设置为**开启**。 1. 对于**写入容量**，请确保将**自动扩缩**设置为**开启**。 1. 对于**读取容量**和**写入容量**，请为表以及表的所有全局二级索引（可选）设置所需的扩展策略。 + **最小容量单位** – 输入自动扩缩范围的下限。 + **最大容量单位** – 输入自动扩缩范围的上限。 + **目标利用率** - 输入表的目标利用率百分比。 **注意** 如果为新表创建全局二级索引，则该索引在创建时的容量将与基表的容量相同。创建表后，您可以在表的设置中更改索引的容量。 1. 选择**创建表**。这会使用您指定的自动扩缩参数创建表。 ## 在现有表上启用 DynamoDB 自动扩缩 **注意** DynamoDB 自动扩缩功能需要存在一个代表您执行自动扩缩操作的服务相关角色（`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`）。将自动为您创建此角色。有关更多信息，请参阅 [Application Auto Scaling 的服务相关角色](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html)。 **为现有表启用 DynamoDB 自动扩缩** 1. 打开 DynamoDB 控制台：[https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)。 1. 在控制台左侧的导航窗格中，选择**表**。 1. 选择您要启用自动扩缩的表，然后执行以下操作： 1. 选择**其他设置**选项卡。 1. 在**读/写容量**部分中，选择**编辑**。 1. 在**容量模式**部分中，选择**预调配**。 1. 在**表容量**部分，对于**读取容量**和/或**写入容量**，将**自动扩缩**设置为**开启**。对于其中每一个，请为表以及表的所有全局二级索引（可选）设置所需的扩展策略。 + **最小容量单位** – 输入自动扩缩范围的下限。 + **最大容量单位** – 输入自动扩缩范围的上限。 + **目标利用率** - 输入表的目标利用率百分比。 + **将相同的读/写容量设置应用于所有全局二级索引** – 选择全局二级索引是否应使用与基表相同的自动扩缩策略。 **注意** 为获得最佳性能，建议您启用**将相同的读/写容量设置应用于所有全局二级索引**。此选项允许 DynamoDB 自动扩缩均匀扩展表上的所有全局二级索引。这包括现有的全局二级索引，以及您将来为此表创建的任何其他索引。 启用此选项后，您无法对单个全局二级索引设置扩展策略。 1. 根据需要进行设置后，选择 **Save (保存)**。 ## 在控制台上查看自动扩缩活动 当您的应用程序驱动对表进行读取和写入流量时，DynamoDB 自动扩缩功能会动态修改表的吞吐量设置。Amazon CloudWatch 会跟踪所有 DynamoDB 表和二级索引的预配置和使用的容量、受限事件、延迟以及其他指标。 要在 DynamoDB 控制台中查看这些指标，请选择要处理的表，然后选择**监控**选项卡。要创建表指标的可自定义视图，请选择 **View all in CloudWatch (在 CloudWatch 中查看全部)**。 ## 修改或禁用 DynamoDB 自动扩缩设置 您可以使用 AWS 管理控制台 修改 DynamoDB 自动扩缩设置。要执行此操作，请转至表的**其他设置**选项卡，然后选择**读/写容量**部分中的**编辑**。有关这些设置的更多信息，请参阅 [在现有表上启用 DynamoDB 自动扩缩](#AutoScaling.Console.ExistingTable)。 # 使用 AWS CLI 管理 DynamoDB 自动扩缩 您可以不再使用 AWS 管理控制台，而改为使用 AWS Command Line Interface（AWS CLI）来管理 Amazon DynamoDB 自动扩缩。本部分中的教程演示如何安装和配置 AWS CLI 来管理 DynamoDB 自动扩缩。在本教程中，您将执行以下操作： + 创建 DynamoDB 表 `TestTable`。初始吞吐量设置为 5 个读取容量单位和 5 个写入容量单位。 + 为 `TestTable` 创建 Application Auto Scaling 策略。该策略旨在将消耗的写入容量和预置的写入容量之间的比例维持在 50% 这一目标值。此指标的范围是 5 到 10 个写入容量单位。（不允许 Application Auto Scaling 调整超出此范围的吞吐量。） + 运行 Python 程序以将写入流量驱动到 `TestTable`。当目标比率在持续时间内超过 50% 时，Application Auto Scaling 会通知 DynamoDB 调整 `TestTable` 以维持 50% 的目标利用率。 + 验证 DynamoDB 是否已成功调整了 `TestTable` 的预置写入容量。 **注意** 您还可以安排 DynamoDB 扩展，使其在特定时间进行。点击[此处](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html)了解基本步骤。 **Topics** + [开始前的准备工作](#AutoScaling.CLI.BeforeYouBegin) + [步骤 1：创建 DynamoDB 表](#AutoScaling.CLI.CreateTable) + [第 2 步：注册一个可扩展目标](#AutoScaling.CLI.RegisterScalableTarget) + [第 3 步：创建一个扩展策略](#AutoScaling.CLI.CreateScalingPolicy) + [第 4 步：将写入流量路由到 TestTable](#AutoScaling.CLI.DriveTraffic) + [第 5 步：查看 Application Auto Scaling 操作](#AutoScaling.CLI.ViewCWAlarms) + [（可选）第 6 步：清除](#AutoScaling.CLI.CleanUp) ## 开始前的准备工作 开始教程前前，请完成以下任务： ### 安装 AWS CLI 如果您尚未安装和配置 AWS CLI，则必须先执行此操作。为此，请按照 *AWS Command Line Interface 用户指南*中的这些指示操作： + [安装 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) + [配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) ### 安装 Python 本教程的一部分要求您运行 Python 程序（请参阅 [第 4 步：将写入流量路由到 TestTable](#AutoScaling.CLI.DriveTraffic)）。如果还没有安装，可以[下载 Python](https://www.python.org/downloads)。 ## 步骤 1：创建 DynamoDB 表 在此步骤中，您将使用 AWS CLI 创建一个 `TestTable`。主键包含 `pk`（分区键）和 `sk`（排序键）。这两个属性的类型为 `Number`。初始吞吐量设置为 5 个读取容量单位和 5 个写入容量单位。 1. 输入以下 AWS CLI 命令以创建表。 ``` aws dynamodb create-table \ --table-name TestTable \ --attribute-definitions \ AttributeName=pk,AttributeType=N \ AttributeName=sk,AttributeType=N \ --key-schema \ AttributeName=pk,KeyType=HASH \ AttributeName=sk,KeyType=RANGE \ --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 ``` 1. 要查看表的状态，请使用以下命令。 ``` aws dynamodb describe-table \ --table-name TestTable \ --query "Table.[TableName,TableStatus,ProvisionedThroughput]" ``` 当状态为 `ACTIVE` 时，表已可供使用。 ## 第 2 步：注册一个可扩展目标 接下来，将将表的写入容量注册为使 Application Auto Scaling 的可扩展目标。这允许 Application Auto Scaling 调整 *TestTable*，但仅在 5—10 个容量单位的范围内。 **注意** DynamoDB 自动扩缩功能需要存在一个代表您执行自动扩缩操作的服务相关角色（`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`）。将自动为您创建此角色。有关更多信息，请参阅《Application Auto Scaling 用户指南》**中的 [Service-linked roles for Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html)。 1. 输入下面的命令注册可扩展目标。 ``` aws application-autoscaling register-scalable-target \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" \ --min-capacity 5 \ --max-capacity 10 ``` 1. 要检验注册，使用下面的命令。 ``` aws application-autoscaling describe-scalable-targets \ --service-namespace dynamodb \ --resource-id "table/TestTable" ``` **注意** 您还可以针对全局二级索引注册可扩展目标。例如，对于全局二级索引（“test index”），资源 ID 和可扩展维度参数都会相应地更新。 ``` aws application-autoscaling register-scalable-target \ --service-namespace dynamodb \ --resource-id "table/TestTable/index/test-index" \ --scalable-dimension "dynamodb:index:WriteCapacityUnits" \ --min-capacity 5 \ --max-capacity 10 ``` ## 第 3 步：创建一个扩展策略 在此步骤中，您将为 `TestTable` 创建扩展政策。该策略定义 Application Auto Scaling 调整表的预调配吞吐量的详细信息，调整表的预调配吞吐量，以及调整表的预调配吞吐量。将此策略与您上一步定义的可扩展目标（`TestTable` 表的写入容量单位）相关联。 该策略包含以下元素： + `PredefinedMetricSpecification`-允许应 Application Auto Scaling 调整的指标。对于 DynamoDB，以下值是 `PredefinedMetricType` 的有效值 + `DynamoDBReadCapacityUtilization` + `DynamoDBWriteCapacityUtilization` + `ScaleOutCooldown`-增加预调配吞吐量的每个 Application Auto Scaling 事件之间的最短时间（以秒为单位）。此参数允许应 Application Auto Scaling 不断增加吞吐量，以响应实际工作负载。`ScaleOutCooldown` 的默认设置为 0。 + `ScaleInCooldown`-减少预配置吞吐量的每个 Application Auto Scaling 事件之间的最短时间（以秒为单位）。此参数允许 Application Auto Scaling 逐步和可预测地降低吞吐量。`ScaleInCooldown` 的默认设置为 0。 + `TargetValue`—Application Auto Scaling 可确保消耗的容量与预置容量的比例保持在该值或接近该值。您将 `TargetValue` 定义为百分比。 **注意** 为了进一步了解 `TargetValue` 的工作原理，假设您的表的预配置吞吐量设置为 200 个写入容量单位。您决定为此表创建扩展策略，并使用 `TargetValue` 的 70%。 现在假设您开始将写入流量驱动到表，以便实际写入吞吐量为 150 个容量单位。占用预置比现在为 (150/200)，即 75%。此比率超出了您的目标值，因此 Application Auto Scaling 会将预置写入容量增加到 215，使该比率为（150/215）或 69.77% – 尽可能接近 `TargetValue`，但不超过。 对于 `TestTable`，您可以设置 `TargetValue` 增加 50%。Application Auto Scaling 在 5-10 个容量单位范围内调整表的预调配吞吐量（请参阅 [第 2 步：注册一个可扩展目标](#AutoScaling.CLI.RegisterScalableTarget)），以便使消耗/预置比例保持或接近 50%。您可以将 `ScaleOutCooldown` 和 `ScaleInCooldown` 值设置为 60 秒。 1. 使用以下内容创建名为 `scaling-policy.json` 的文件。 ``` { "PredefinedMetricSpecification": { "PredefinedMetricType": "DynamoDBWriteCapacityUtilization" }, "ScaleOutCooldown": 60, "ScaleInCooldown": 60, "TargetValue": 50.0 } ``` 1. 使用以下 AWS CLI 命令创建策略： ``` aws application-autoscaling put-scaling-policy \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" \ --policy-name "MyScalingPolicy" \ --policy-type "TargetTrackingScaling" \ --target-tracking-scaling-policy-configuration file://scaling-policy.json ``` 1. 在输出中，请注意，Application Auto Scaling 已创建两个 Amazon CloudWatch 警报，分别针对扩展目标范围的上限和下限。 1. 请使用以下 AWS CLI 命令查看有关扩展策略的更多详细信息。 ``` aws application-autoscaling describe-scaling-policies \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --policy-name "MyScalingPolicy" ``` 1. 在输出中，验证策略设置是否符合 [第 2 步：注册一个可扩展目标](#AutoScaling.CLI.RegisterScalableTarget) 和 [第 3 步：创建一个扩展策略](#AutoScaling.CLI.CreateScalingPolicy) 规范。 ## 第 4 步：将写入流量路由到 TestTable 现在，可以将数据写入到 `TestTable` 测试扩展策略。要执行此操作，请运行 Python 程序。 1. 使用以下内容创建名为 `bulk-load-test-table.py` 的文件。 ``` import boto3 dynamodb = boto3.resource('dynamodb') table = dynamodb.Table("TestTable") filler = "x" * 100000 i = 0 while (i < 10): j = 0 while (j < 10): print (i, j) table.put_item( Item={ 'pk':i, 'sk':j, 'filler':{"S":filler} } ) j += 1 i += 1 ``` 1. 要运行该程序，请输入以下命令。 `python bulk-load-test-table.py` 预置写入容量 `TestTable` 非常低（5 个写入容量单位），因此程序偶尔会因写入限制而停顿。这是预料之中的行为。 让程序继续运行，同时继续下一步。 ## 第 5 步：查看 Application Auto Scaling 操作 在此步骤中，您可查看代表您启动的 Application Auto Scaling 操作。您还可以验证 Application Auto Scaling 已更新 `TestTable` 的预置写入容量。 1. 输入以下命令以查看 Application Auto Scaling 操作。 ``` aws application-autoscaling describe-scaling-activities \ --service-namespace dynamodb ``` 在 Python 程序运行时偶尔重新运行此命令。（调用扩展策略之前需要几分钟。） 最终应看到如下输出。 ``` ... { "ScalableDimension": "dynamodb:table:WriteCapacityUnits", "Description": "Setting write capacity units to 10.", "ResourceId": "table/TestTable", "ActivityId": "0cc6fb03-2a7c-4b51-b67f-217224c6b656", "StartTime": 1489088210.175, "ServiceNamespace": "dynamodb", "EndTime": 1489088246.85, "Cause": "monitor alarm AutoScaling-table/TestTable-AlarmHigh-1bb3c8db-1b97-4353-baf1-4def76f4e1b9 in state ALARM triggered policy MyScalingPolicy", "StatusMessage": "Successfully set write capacity units to 10. Change successfully fulfilled by dynamodb.", "StatusCode": "Successful" }, ... ``` 这表示 Application Auto Scaling 已将 `UpdateTable` 请求发送给 DynamoDB。 1. 输入以下命令以验证 DynamoDB 是否增加了表的写入容量。 ``` aws dynamodb describe-table \ --table-name TestTable \ --query "Table.[TableName,TableStatus,ProvisionedThroughput]" ``` `WriteCapacityUnits` 应该从 `5` 扩展到 `10`。 ## （可选）第 6 步：清除 在本教程中，您创建了多个资源。如果您不再需要这些资源，就可以删除它们了。 1. 删除 `TestTable` 的扩展策略。 ``` aws application-autoscaling delete-scaling-policy \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" \ --policy-name "MyScalingPolicy" ``` 1. 取消注册可扩展目标。 ``` aws application-autoscaling deregister-scalable-target \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" ``` 1. 删除 `TestTable` 表。 ``` aws dynamodb delete-table --table-name TestTable ``` # 使用 AWS SDK 为 Amazon DynamoDB 表配置自动扩缩功能 除了使用 AWS 管理控制台 和 AWS Command Line Interface (AWS CLI) 之外，还可以编写与 Amazon DynamoDB Auto Scaling 交互的应用程序。本节包含两个可用于测试此功能的 Java 程序： + `EnableDynamoDBAutoscaling.java` + `DisableDynamoDBAutoscaling.java` ## 为表启用 Application Auto Scaling 以下程序显示了为 DynamoDB 表 (`TestTable`) 设置自动扩缩策略的示例。其操作过程如下所示： + 程序将写入容量单位注册为 `TestTable` 的可扩展目标。此指标的范围是 5 到 10 个写入容量单位。 + 创建可扩展目标后，程序将构建目标跟踪配置。该策略旨在将消耗的写入容量和预置的写入容量之间的比例维持在 50% 这一目标值。 + 然后，程序基于目标跟踪配置创建缩放策略。 **注意** 手动删除表或全局表副本时，不会自动删除任何关联的可扩展目标、扩缩策略或 CloudWatch 告警。 ------ #### [ Java v2 ] ``` import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.applicationautoscaling.ApplicationAutoScalingClient; import software.amazon.awssdk.services.applicationautoscaling.model.ApplicationAutoScalingException; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalableTargetsRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalableTargetsResponse; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalingPoliciesRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalingPoliciesResponse; import software.amazon.awssdk.services.applicationautoscaling.model.PolicyType; import software.amazon.awssdk.services.applicationautoscaling.model.PredefinedMetricSpecification; import software.amazon.awssdk.services.applicationautoscaling.model.PutScalingPolicyRequest; import software.amazon.awssdk.services.applicationautoscaling.model.RegisterScalableTargetRequest; import software.amazon.awssdk.services.applicationautoscaling.model.ScalingPolicy; import software.amazon.awssdk.services.applicationautoscaling.model.ServiceNamespace; import software.amazon.awssdk.services.applicationautoscaling.model.ScalableDimension; import software.amazon.awssdk.services.applicationautoscaling.model.MetricType; import software.amazon.awssdk.services.applicationautoscaling.model.TargetTrackingScalingPolicyConfiguration; import java.util.List; /** * Before running this Java V2 code example, set up your development environment, including your credentials. * * For more information, see the following documentation topic: * * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html */ public class EnableDynamoDBAutoscaling { public static void main(String[] args) { final String usage = """ Usage: \s Where: tableId - The table Id value (for example, table/Music). roleARN - The ARN of the role that has ApplicationAutoScaling permissions. policyName - The name of the policy to create. """; if (args.length != 3) { System.out.println(usage); System.exit(1); } System.out.println("This example registers an Amazon DynamoDB table, which is the resource to scale."); String tableId = args[0]; String roleARN = args[1]; String policyName = args[2]; ServiceNamespace ns = ServiceNamespace.DYNAMODB; ScalableDimension tableWCUs = ScalableDimension.DYNAMODB_TABLE_WRITE_CAPACITY_UNITS; ApplicationAutoScalingClient appAutoScalingClient = ApplicationAutoScalingClient.builder() .region(Region.US_EAST_1) .build(); registerScalableTarget(appAutoScalingClient, tableId, roleARN, ns, tableWCUs); verifyTarget(appAutoScalingClient, tableId, ns, tableWCUs); configureScalingPolicy(appAutoScalingClient, tableId, ns, tableWCUs, policyName); } public static void registerScalableTarget(ApplicationAutoScalingClient appAutoScalingClient, String tableId, String roleARN, ServiceNamespace ns, ScalableDimension tableWCUs) { try { RegisterScalableTargetRequest targetRequest = RegisterScalableTargetRequest.builder() .serviceNamespace(ns) .scalableDimension(tableWCUs) .resourceId(tableId) .roleARN(roleARN) .minCapacity(5) .maxCapacity(10) .build(); appAutoScalingClient.registerScalableTarget(targetRequest); System.out.println("You have registered " + tableId); } catch (ApplicationAutoScalingException e) { System.err.println(e.awsErrorDetails().errorMessage()); } } // Verify that the target was created. public static void verifyTarget(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs) { DescribeScalableTargetsRequest dscRequest = DescribeScalableTargetsRequest.builder() .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceIds(tableId) .build(); DescribeScalableTargetsResponse response = appAutoScalingClient.describeScalableTargets(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(response); } // Configure a scaling policy. public static void configureScalingPolicy(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs, String policyName) { // Check if the policy exists before creating a new one. DescribeScalingPoliciesResponse describeScalingPoliciesResponse = appAutoScalingClient.describeScalingPolicies(DescribeScalingPoliciesRequest.builder() .serviceNamespace(ns) .resourceId(tableId) .scalableDimension(tableWCUs) .build()); if (!describeScalingPoliciesResponse.scalingPolicies().isEmpty()) { // If policies exist, consider updating an existing policy instead of creating a new one. System.out.println("Policy already exists. Consider updating it instead."); List polList = describeScalingPoliciesResponse.scalingPolicies(); for (ScalingPolicy pol : polList) { System.out.println("Policy name:" +pol.policyName()); } } else { // If no policies exist, proceed with creating a new policy. PredefinedMetricSpecification specification = PredefinedMetricSpecification.builder() .predefinedMetricType(MetricType.DYNAMO_DB_WRITE_CAPACITY_UTILIZATION) .build(); TargetTrackingScalingPolicyConfiguration policyConfiguration = TargetTrackingScalingPolicyConfiguration.builder() .predefinedMetricSpecification(specification) .targetValue(50.0) .scaleInCooldown(60) .scaleOutCooldown(60) .build(); PutScalingPolicyRequest putScalingPolicyRequest = PutScalingPolicyRequest.builder() .targetTrackingScalingPolicyConfiguration(policyConfiguration) .serviceNamespace(ns) .scalableDimension(tableWCUs) .resourceId(tableId) .policyName(policyName) .policyType(PolicyType.TARGET_TRACKING_SCALING) .build(); try { appAutoScalingClient.putScalingPolicy(putScalingPolicyRequest); System.out.println("You have successfully created a scaling policy for an Application Auto Scaling scalable target"); } catch (ApplicationAutoScalingException e) { System.err.println("Error: " + e.awsErrorDetails().errorMessage()); } } } } ``` ------ #### [ Java v1 ] 程序要求您为有效的 Application Auto Scaling 服务相关角色提供 Amazon Resource Name (ARN)。例如：`arn:aws:iam::122517410325:role/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`。在以下程序中，用实际的 ARN 替换 `SERVICE_ROLE_ARN_GOES_HERE`。 ``` package com.amazonaws.codesamples.autoscaling; import com.amazonaws.services.applicationautoscaling.AWSApplicationAutoScalingClient; import com.amazonaws.services.applicationautoscaling.AWSApplicationAutoScalingClientBuilder; import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsResult; import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesResult; import com.amazonaws.services.applicationautoscaling.model.MetricType; import com.amazonaws.services.applicationautoscaling.model.PolicyType; import com.amazonaws.services.applicationautoscaling.model.PredefinedMetricSpecification; import com.amazonaws.services.applicationautoscaling.model.PutScalingPolicyRequest; import com.amazonaws.services.applicationautoscaling.model.RegisterScalableTargetRequest; import com.amazonaws.services.applicationautoscaling.model.ScalableDimension; import com.amazonaws.services.applicationautoscaling.model.ServiceNamespace; import com.amazonaws.services.applicationautoscaling.model.TargetTrackingScalingPolicyConfiguration; public class EnableDynamoDBAutoscaling { static AWSApplicationAutoScalingClient aaClient = (AWSApplicationAutoScalingClient) AWSApplicationAutoScalingClientBuilder .standard().build(); public static void main(String args[]) { ServiceNamespace ns = ServiceNamespace.Dynamodb; ScalableDimension tableWCUs = ScalableDimension.DynamodbTableWriteCapacityUnits; String resourceID = "table/TestTable"; // Define the scalable target RegisterScalableTargetRequest rstRequest = new RegisterScalableTargetRequest() .withServiceNamespace(ns) .withResourceId(resourceID) .withScalableDimension(tableWCUs) .withMinCapacity(5) .withMaxCapacity(10) .withRoleARN("SERVICE_ROLE_ARN_GOES_HERE"); try { aaClient.registerScalableTarget(rstRequest); } catch (Exception e) { System.err.println("Unable to register scalable target: "); System.err.println(e.getMessage()); } // Verify that the target was created DescribeScalableTargetsRequest dscRequest = new DescribeScalableTargetsRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceIds(resourceID); try { DescribeScalableTargetsResult dsaResult = aaClient.describeScalableTargets(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(dsaResult); System.out.println(); } catch (Exception e) { System.err.println("Unable to describe scalable target: "); System.err.println(e.getMessage()); } System.out.println(); // Configure a scaling policy TargetTrackingScalingPolicyConfiguration targetTrackingScalingPolicyConfiguration = new TargetTrackingScalingPolicyConfiguration() .withPredefinedMetricSpecification( new PredefinedMetricSpecification() .withPredefinedMetricType(MetricType.DynamoDBWriteCapacityUtilization)) .withTargetValue(50.0) .withScaleInCooldown(60) .withScaleOutCooldown(60); // Create the scaling policy, based on your configuration PutScalingPolicyRequest pspRequest = new PutScalingPolicyRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID) .withPolicyName("MyScalingPolicy") .withPolicyType(PolicyType.TargetTrackingScaling) .withTargetTrackingScalingPolicyConfiguration(targetTrackingScalingPolicyConfiguration); try { aaClient.putScalingPolicy(pspRequest); } catch (Exception e) { System.err.println("Unable to put scaling policy: "); System.err.println(e.getMessage()); } // Verify that the scaling policy was created DescribeScalingPoliciesRequest dspRequest = new DescribeScalingPoliciesRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID); try { DescribeScalingPoliciesResult dspResult = aaClient.describeScalingPolicies(dspRequest); System.out.println("DescribeScalingPolicies result: "); System.out.println(dspResult); } catch (Exception e) { e.printStackTrace(); System.err.println("Unable to describe scaling policy: "); System.err.println(e.getMessage()); } } } ``` ------ ## 禁用表的 Application Auto Scaling 以下程序将反转前面的过程。它删除 Auto Scaling 策略，然后撤消可扩展目标的注册。 ------ #### [ Java v2 ] ``` import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.applicationautoscaling.ApplicationAutoScalingClient; import software.amazon.awssdk.services.applicationautoscaling.model.ApplicationAutoScalingException; import software.amazon.awssdk.services.applicationautoscaling.model.DeleteScalingPolicyRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DeregisterScalableTargetRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalableTargetsRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalableTargetsResponse; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalingPoliciesRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalingPoliciesResponse; import software.amazon.awssdk.services.applicationautoscaling.model.ScalableDimension; import software.amazon.awssdk.services.applicationautoscaling.model.ServiceNamespace; /** * Before running this Java V2 code example, set up your development environment, including your credentials. * * For more information, see the following documentation topic: * * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html */ public class DisableDynamoDBAutoscaling { public static void main(String[] args) { final String usage = """ Usage: \s Where: tableId - The table Id value (for example, table/Music).\s policyName - The name of the policy (for example, $Music5-scaling-policy). """; if (args.length != 2) { System.out.println(usage); System.exit(1); } ApplicationAutoScalingClient appAutoScalingClient = ApplicationAutoScalingClient.builder() .region(Region.US_EAST_1) .build(); ServiceNamespace ns = ServiceNamespace.DYNAMODB; ScalableDimension tableWCUs = ScalableDimension.DYNAMODB_TABLE_WRITE_CAPACITY_UNITS; String tableId = args[0]; String policyName = args[1]; deletePolicy(appAutoScalingClient, policyName, tableWCUs, ns, tableId); verifyScalingPolicies(appAutoScalingClient, tableId, ns, tableWCUs); deregisterScalableTarget(appAutoScalingClient, tableId, ns, tableWCUs); verifyTarget(appAutoScalingClient, tableId, ns, tableWCUs); } public static void deletePolicy(ApplicationAutoScalingClient appAutoScalingClient, String policyName, ScalableDimension tableWCUs, ServiceNamespace ns, String tableId) { try { DeleteScalingPolicyRequest delSPRequest = DeleteScalingPolicyRequest.builder() .policyName(policyName) .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceId(tableId) .build(); appAutoScalingClient.deleteScalingPolicy(delSPRequest); System.out.println(policyName +" was deleted successfully."); } catch (ApplicationAutoScalingException e) { System.err.println(e.awsErrorDetails().errorMessage()); } } // Verify that the scaling policy was deleted public static void verifyScalingPolicies(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs) { DescribeScalingPoliciesRequest dscRequest = DescribeScalingPoliciesRequest.builder() .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceId(tableId) .build(); DescribeScalingPoliciesResponse response = appAutoScalingClient.describeScalingPolicies(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(response); } public static void deregisterScalableTarget(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs) { try { DeregisterScalableTargetRequest targetRequest = DeregisterScalableTargetRequest.builder() .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceId(tableId) .build(); appAutoScalingClient.deregisterScalableTarget(targetRequest); System.out.println("The scalable target was deregistered."); } catch (ApplicationAutoScalingException e) { System.err.println(e.awsErrorDetails().errorMessage()); } } public static void verifyTarget(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs) { DescribeScalableTargetsRequest dscRequest = DescribeScalableTargetsRequest.builder() .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceIds(tableId) .build(); DescribeScalableTargetsResponse response = appAutoScalingClient.describeScalableTargets(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(response); } } ``` ------ #### [ Java v1 ] ``` package com.amazonaws.codesamples.autoscaling; import com.amazonaws.services.applicationautoscaling.AWSApplicationAutoScalingClient; import com.amazonaws.services.applicationautoscaling.model.DeleteScalingPolicyRequest; import com.amazonaws.services.applicationautoscaling.model.DeregisterScalableTargetRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsResult; import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesResult; import com.amazonaws.services.applicationautoscaling.model.ScalableDimension; import com.amazonaws.services.applicationautoscaling.model.ServiceNamespace; public class DisableDynamoDBAutoscaling { static AWSApplicationAutoScalingClient aaClient = new AWSApplicationAutoScalingClient(); public static void main(String args[]) { ServiceNamespace ns = ServiceNamespace.Dynamodb; ScalableDimension tableWCUs = ScalableDimension.DynamodbTableWriteCapacityUnits; String resourceID = "table/TestTable"; // Delete the scaling policy DeleteScalingPolicyRequest delSPRequest = new DeleteScalingPolicyRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID) .withPolicyName("MyScalingPolicy"); try { aaClient.deleteScalingPolicy(delSPRequest); } catch (Exception e) { System.err.println("Unable to delete scaling policy: "); System.err.println(e.getMessage()); } // Verify that the scaling policy was deleted DescribeScalingPoliciesRequest descSPRequest = new DescribeScalingPoliciesRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID); try { DescribeScalingPoliciesResult dspResult = aaClient.describeScalingPolicies(descSPRequest); System.out.println("DescribeScalingPolicies result: "); System.out.println(dspResult); } catch (Exception e) { e.printStackTrace(); System.err.println("Unable to describe scaling policy: "); System.err.println(e.getMessage()); } System.out.println(); // Remove the scalable target DeregisterScalableTargetRequest delSTRequest = new DeregisterScalableTargetRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID); try { aaClient.deregisterScalableTarget(delSTRequest); } catch (Exception e) { System.err.println("Unable to deregister scalable target: "); System.err.println(e.getMessage()); } // Verify that the scalable target was removed DescribeScalableTargetsRequest dscRequest = new DescribeScalableTargetsRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceIds(resourceID); try { DescribeScalableTargetsResult dsaResult = aaClient.describeScalableTargets(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(dsaResult); System.out.println(); } catch (Exception e) { System.err.println("Unable to describe scalable target: "); System.err.println(e.getMessage()); } } } ``` ------