# DynamoDB Auto Scaling によるスループットキャパシティの自動管理
<a name="AutoScaling"></a>

多くのデータベースワークロードは本質的に循環的なものであり、前もって予測することが困難なものもあります。例えば、日中の時間帯に大部分のユーザーがアクティブなソーシャルネットワーキングアプリがあるとします。データベースは日中のアクティビティを処理できる必要がありますが、夜間のスループットに同じレベルは必要ありません。別の例としては、予想以上に急速に普及した新しいモバイルゲームアプリが挙げられます。ゲームがあまりに人気になると、利用可能なデータベースリソースを超過し、パフォーマンスが低下して顧客が不満を感じるようになります。この種のワークロードでは多くの場合、手動介入によってデータベースリソースを使用レベルに応じて上下させる必要があります。

Amazon DynamoDB Auto Scaling は AWS Application Auto Scaling サービスを使用し、実際のトラフィックパターンに応じてプロビジョンドスループット性能をユーザーに代わって動的に調節します。これにより、テーブルまたはグローバルセカンダリインデックス (GSI) では、読み取りと書き込みのプロビジョンドキャパシティを増やし、スロットリングなしでトラフィックの急増に対処できます。ワークロードが減ると、Application Auto Scaling はスループットを低下させ、未使用のプロビジョンされた容量に料金が発生しないようにします。

**注記**  
AWS マネジメントコンソール を使用してテーブルまたはグローバルセカンダリインデックスを作成すると、デフォルトで DynamoDB Auto Scaling が有効になります。Auto Scaling の設定はいつでも変更できます。詳細については、「[AWS マネジメントコンソール と DynamoDB Auto Scaling の使用](AutoScaling.Console.md)」を参照してください。  
テーブルまたはグローバルテーブルレプリカを削除しても、関連するスケーラブルターゲット、スケーリングポリシー、または CloudWatch アラームが共に自動的に削除されることはありません。

Application Auto Scaling を使用して、テーブルまたはグローバルセカンダリインデックスの*スケーリングポリシー*を作成します。スケーリングポリシーは、テーブルまたはインデックスの読み込みキャパシティまたは書き込みキャパシティ (またはその両方) およびプロビジョニングされたキャパシティユニット設定をスケーリングするかどうかを指定します。

スケーリングポリシーには、*ターゲット使用率* (ある時点で消費したプロビジョン済みスループットの割合) も含まれます。Application Auto Scaling は*のターゲット追跡*アルゴリズムを使用して、実際のワークロードに応じてテーブル (インデックス) のプロビジョンスループットを上下に調整することで、実際の容量使用率がターゲット使用率に、またはその近くに留まるようにします。

DynamoDB は、消費されたプロビジョンドスループットを 1 分間出力します。消費されたキャパシティが、設定したターゲット使用率を 2 分間連続して超過すると、自動スケーリングがトリガーされます。CloudWatch アラームは、自動スケーリングをトリガーする前に、最大数分の短い遅延を伴う場合があります。この遅延により、CloudWatch メトリクスの正確な評価が保証されます。消費されたスループットのスパイク間隔が 1 分を超えると、自動スケーリングはトリガーされない場合があります。同様に、15 個の連続するデータポイントがターゲット使用率を下回ると、スケールダウンイベントが発生する場合があります。いずれの場合も、自動スケーリングのトリガー後に、[UpdateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html) API が呼び出されます。テーブルやインデックスのプロビジョンドキャパシティの更新には、数分かかる場合があります。この間に、テーブルの前のプロビジョンドキャパシティを超えるリクエストはスロットリングされます。

**重要**  
侵害するデータポイントの数を調整して、基礎となるアラームをトリガーすることはできません (ただし、現在の数は将来変更される可能性があります)。

 読み取りおよび書き込み容量に対して、Auto Scaling ターゲット使用率の値を 20% から 90% の間で設定できます。

**注記**  
テーブルに加え、DynamoDB Auto Scaling はグローバルセカンダリインデックスもサポートします。すべてのグローバルセカンダリインデックスは、基本テーブルとは別に、固有のプロビジョンドスループット性能を持ちます。グローバルセカンダリインデックスのスケーリングポリシーを作成すると、Application Auto Scaling がインデックスのプロビジョンされたスループット設定を調整し、実際の使用率がターゲット使用率と同じか近い値で維持されるようになります。

## DynamoDB Auto Scaling の仕組み
<a name="AutoScaling.HowItWorks"></a>

**注記**  
DynamoDB Auto Scaling の簡単な使用方法については、[AWS マネジメントコンソール と DynamoDB Auto Scaling の使用](AutoScaling.Console.md) を参照してください。

次の図表は、DynamoDB Auto Scaling によるテーブルのスループットキャパシティの管理方法について、高レベルの概要を示しています。

![\[DynamoDB Auto Scaling は、需要に合わせてテーブルのスループットキャパシティを調整します。\]](http://docs.aws.amazon.com/ja_jp/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 メトリクスをモニタリングすることにより、テーブルに 1,200 ユニットの読み込み容量が必要である (アクティビティのピーク時に DynamoDB が読み込みリクエストをスロットリングしないため) と判断します。さらに、読み込みトラフィックが最も低い時点で、`ProductCatalog` には最少で 150 ユニットの読み込みキャパシティが必要です。スロットリングの防止の詳細については、「[Amazon DynamoDB でのスロットリングのトラブルシューティング](TroubleshootingThrottling.md)」を参照してください。

読み込みキャパシティ 150～1,200 ユニットの範囲内で、`ProductCatalog` に適したターゲット使用率 70% を決定します。*ターゲット使用率*は、プロビジョンされた容量単位に対して消費された容量単位の割合がパーセンテージで示されます。Application Auto Scaling は、ターゲット追跡アルゴリズムを使用して、`ProductCatalog` のプロビジョンされた読み込み容量が必要に応じて調整され、使用率が 70% またはその近くに留まるようにします。

**注記**  
DynamoDB 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 をコールし、`ProductCatalog` テーブルのプロビジョン容量を必要に応じて調整するように DynamoDB に通知します。

スケーリングイベント中、AWS Config は記録された設定項目ごとに課金されます。スケーリングイベントが発生すると、読み取り/書き込み自動スケーリングイベントごとに 4 つの CloudWatch アラームが作成されます。ProvisionedCapacity アラーム: ProvisionedCapacityLow、ProvisionedCapacityHigh、および ConsumedCapacity アラーム: AlarmHigh、AlarmLow です。その結果、合計 8 つのアラームが生成されます。そのため、AWS Config は、スケーリングイベントごとに 8 つの設定項目を記録します。

**注記**  
また、DynamoDB のスケーリングを特定の時間に実行するようにスケジュールすることもできます。基本的な手順については、[こちら](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html)を参照してください。

## 使用に関する注意事項
<a name="AutoScaling.UsageNotes"></a>

DynamoDB Auto Scaling の使用を開始する前に、以下を確認する必要があります。
+ DynamoDB Auto Scaling は、自動スケーリングポリシーに従って、読み込み容量や書き込み容量を必要に応じて増加させます。[Amazon DynamoDB のクォータ](ServiceQuotas.md) で説明されているように、すべての DynamoDB クォータは有効です。
+ DynamoDB Auto Scaling により、プロビジョンされたスループット設定を手動で変更できなくなることはありません。これらの手動調整が、DynamoDB Auto Scaling に関連する既存の CloudWatch アラームに影響することはありません。
+ 1 つ以上のグローバルセカンダリインデックスを持つテーブルの DynamoDB Auto Scaling を有効にする場合、これらのインデックスに Auto Scaling を均等に適用することをお勧めします。これにより、テーブルの書き込みと読み取りのパフォーマンスが向上し、スロットリングを回避できます。　 auto scaling を有効にするには、AWS マネジメントコンソール で **[Apply same settings to global secondary indexes]** (グローバルセカンダリインデックスに同じ設定を適用する) を選択します。詳細については、「[既存のテーブルでの DynamoDB Auto Scaling の有効化](AutoScaling.Console.md#AutoScaling.Console.ExistingTable)」を参照してください。
+ テーブルまたはグローバルテーブルレプリカを削除しても、関連するスケーラブルターゲット、スケーリングポリシー、または CloudWatch アラームが共に自動的に削除されることはありません。
+ 既存のテーブルの GSI を作成する場合、その GSI の Auto Scaling は有効になりません。GSI を構築している間は、容量を手動で管理する必要があります。GSI のバックフィルが完了し、アクティブステータスに達すると、Auto Scaling は通常どおり動作します。

# AWS マネジメントコンソール と DynamoDB Auto Scaling の使用
<a name="AutoScaling.Console"></a>

AWS マネジメントコンソール を使用して新しいテーブルを作成すると、Amazon DynamoDB Auto Scaling はデフォルトでそのテーブルに対して有効になります。コンソールを使用して、既存テーブルの Auto Scaling の有効化、Auto Scaling 設定の変更、Auto Scaling の無効化を行うこともできます。

**注記**  
 スケールインおよびスケールアウトのクールダウン時間の設定など、より高度な特徴については、AWS Command Line Interface (AWS CLI) を使用して DynamoDB Auto Scaling を管理します。詳細については、「[AWS CLI を使用した DynamoDB Auto Scaling の管理](AutoScaling.CLI.md)」を参照してください。

**Topics**
+ [開始する前に: DynamoDB Auto Scaling のアクセス許可をユーザーに付与する](#AutoScaling.Permissions)
+ [Auto Scaling を有効にした新しいテーブルの作成](#AutoScaling.Console.NewTable)
+ [既存のテーブルでの DynamoDB Auto Scaling の有効化](#AutoScaling.Console.ExistingTable)
+ [コンソールでの Auto Scaling アクティビティの表示](#AutoScaling.Console.ViewingActivities)
+ [DynamoDB Auto Scaling 設定の変更または無効化](#AutoScaling.Console.Modifying)

## 開始する前に: DynamoDB Auto Scaling のアクセス許可をユーザーに付与する
<a name="AutoScaling.Permissions"></a>

AWS Identity and Access Management (IAM) の場合、AWS マネージドポリシー `DynamoDBFullAccess` は、DynamoDB コンソールを使用するために必要なアクセス許可を提供します。ただし、DynamoDB Auto Scaling の場合、ユーザーには追加アクセス許可が必要です。

**重要**  
 自動スケーリング対応のテーブルを削除するには、`application-autoscaling:*` アクセス許可が必要です。AWS マネージドポリシー `DynamoDBFullAccess` には、必要なアクセス許可が含まれています。

DynamoDB コンソールアクセスと DynamoDB Auto Scaling 用にユーザーを設定するには、ロールを作成し、そのロールに **AmazonDynamoDBFullAccess** ポリシーを追加します。次に、ロールをユーザーに割り当てます。

## Auto Scaling を有効にした新しいテーブルの作成
<a name="AutoScaling.Console.NewTable"></a>

**注記**  
DynamoDB Auto Scaling では、ユーザーに代わって Auto Scaling アクションを実行する、サービスリンクロール (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) の存在を必要とします。このロールは自動的に作成されます。詳細については、「Application Auto Scaling ユーザーガイド」の「[Application Auto Scaling 用のサービスリンクロール](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html)」を参照してください。**

**Auto Scaling を有効にして新しいテーブルを作成するには**

1. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) で DynamoDB コンソールを開きます。

1. [**Create table**] を選択します。

1. **[テーブルを作成]** ページで、**テーブル名**とプライマリキーの詳細を入力します。

1. **[デフォルト設定]** を選択すると、新しいテーブルで自動スケーリングが有効になります。

   それ以外の場合は、**[設定をカスタマイズ]** を選択し、以下の操作を実行してテーブルのカスタム設定を指定します。

   1. **[テーブルクラス]** で、デフォルト設定である **[DynamoDB 標準]** を選択したままにします。

   1. **[読み取り/書き込みキャパシティーの設定]** で、デフォルト設定の **[プロビジョンド]** を選択したままにして、以下の操作を行います。

      1. **[読み取りキャパシティー]** で、**[自動スケーリング]** が **[オン]** に設定されていることを確認します。

      1. **[書き込みキャパシティー]** で、**[自動スケーリング]** が **[オン]** に設定されていることを確認します。

      1. **[読み取りキャパシティー]** と **[書き込みキャパシティー]** で、テーブルに必要なスケーリングポリシーと、オプションでテーブルのすべてのグローバルセカンダリインデックスを設定します。
         + **最小キャパシティーユニット** - Auto Scaling 範囲の下限を入力します。
         + **最大キャパシティーユニット** - Auto Scaling 範囲の上限を入力します。
         + **ターゲット使用率** — テーブルの目標使用率を入力します。
**注記**  
新しいテーブルのグローバルセカンダリインデックスを作成する場合、作成時のインデックスの容量は、ベーステーブルの容量と同じになります。インデックスの容量は、テーブルの作成後にテーブルの設定で変更できます。

1. **[テーブルの作成]** を選択します。これにより、指定した自動スケーリングパラメータを使用してテーブルが作成されます。

## 既存のテーブルでの DynamoDB Auto Scaling の有効化
<a name="AutoScaling.Console.ExistingTable"></a>

**注記**  
DynamoDB Auto Scaling では、ユーザーに代わって Auto Scaling アクションを実行する、サービスリンクロール (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) の存在を必要とします。このロールは自動的に作成されます。詳細については、「[Application Auto Scaling 用のサービスリンクロール](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html)」を参照してください。

**既存のテーブルに対して DynamoDB Auto Scaling を有効にするには**

1. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) で DynamoDB コンソールを開きます。

1. コンソールの左側のナビゲーションペインで、[**テーブル**] を選択します。

1. 自動スケーリングを有効にするテーブルを選択し、以下の操作を行います。

   1. **[追加の設定]** タブを選択します。

   1. **[読み取りキャパシティー]** セクションで、**[編集]** を選択します。

   1. **[キャパシティーモード]** セクションで、**[プロビジョンド]** を選択します。

   1. **[テーブルのキャパシティー]** セクションで、**[読み込みキャパシティー]**、**[書き込みキャパシティー]**、または両方に対して、**[自動スケーリング]** を **[オン]** に設定します。これらのそれぞれについて、テーブルに必要なスケーリングポリシーを設定し、オプションでテーブルのすべてのグローバルセカンダリインデックスを設定します。
      + **最小キャパシティーユニット** - Auto Scaling 範囲の下限を入力します。
      + **最大キャパシティーユニット** - Auto Scaling 範囲の上限を入力します。
      + **ターゲット使用率** — テーブルの目標使用率を入力します。
      + **[すべてのグローバルセカンダリインデックスに同じキャパシティー読み取り/書き込みキャパシティー設定を使用する]** - グローバルセカンダリインデックスがベーステーブルと同じ Auto Scaling ポリシーを使用するかどうかを選択します。
**注記**  
最高のパフォーマンスを実現するには、[**すべてのグローバルセカンダリインデックスに同じ読み取り/書き込み容量設定を適用する**] を有効にすることをお勧めします。このオプションを使用すれば、DynamoDB Auto Scaling は、ベーステーブル上のすべてのグローバルセカンダリインデックスを均一にスケーリングできます。これには、既存のグローバルセカンダリインデックスと、将来このテーブル用に作成するその他のインデックスが含まれます。  
このオプションを有効にすると、個々のグローバルセカンダリインデックスにスケーリングポリシーを設定できなくなります。

1. すべての設定が正しいことを確認したら、[**保存**] を選択します。

## コンソールでの Auto Scaling アクティビティの表示
<a name="AutoScaling.Console.ViewingActivities"></a>

アプリケーションがテーブルへの読み込みおよび書き込みトラフィックを送ると、DynamoDB Auto Scaling はテーブルのスループット設定を動的に変更します。Amazon CloudWatch は、すべての DynamoDB テーブルとセカンダリインデックスについて、プロビジョニングされた容量、消費された容量、スロットルイベント、レイテンシー、およびその他のメトリクスを追跡します。

DynamoDB コンソールでこれらのメトリクスを表示するには、操作するテーブルを選択し、**[モニタリング]** タブを選択します。テーブルメトリクスのカスタマイズ可能なビューを作成するには、[**CloudWatch ですべてを表示**] を選択します。

## DynamoDB Auto Scaling 設定の変更または無効化
<a name="AutoScaling.Console.Modifying"></a>

AWS マネジメントコンソール を使用して、DynamoDB Auto Scaling 設定を変更できます。これを行うには、テーブルの **[追加設定]** タブに移動し、**[読み取り/書き込みキャパシティー]** セクションで **[編集]** を選択します。これらの設定の詳細については、「[既存のテーブルでの DynamoDB Auto Scaling の有効化](#AutoScaling.Console.ExistingTable)」をご参照ください。

# AWS CLI を使用した DynamoDB Auto Scaling の管理
<a name="AutoScaling.CLI"></a>

AWS マネジメントコンソール を使用する代わりに、AWS Command Line Interface (AWS CLI) を使用して、Amazon DynamoDB Auto Scaling を管理できます。このセクションのチュートリアルでは、DynamoDB Auto Scaling を管理するために AWS CLI をインストールして設定する方法を示します。このチュートリアルでは、以下の作業を行います。
+ `TestTable` という DynamoDB テーブルの作成 初期スループット設定では、読み込み容量単位数が 5、書き込み容量単位が 5 です。
+ `TestTable` 用アプリケーションの 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)

## 開始する前に
<a name="AutoScaling.CLI.BeforeYouBegin"></a>

チュートリアルを開始する前に、以下のタスクを完了します。

### AWS CLI をインストールする
<a name="AutoScaling.CLI.BeforeYouBegin.InstallCLI"></a>

まだ 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 のインストール
<a name="AutoScaling.CLI.BeforeYouBegin.InstallPython"></a>

このチュートリアルの一部では、Python プログラムを実行する必要があります ([ステップ 4: 書き込みトラフィックを TestTable に送る](#AutoScaling.CLI.DriveTraffic) を参照)。まだインスタンスしていない場合は、[Python をダウンロード](https://www.python.org/downloads)できます。

## ステップ 1: DynamoDB テーブルを作成する
<a name="AutoScaling.CLI.CreateTable"></a>

このステップでは、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: スケーラブルなターゲットを登録する
<a name="AutoScaling.CLI.RegisterScalableTarget"></a>

次に、Application Auto Scaling を使用して、テーブルの書き込み容量をスケーラブルなターゲットとして登録します。これにより、Application Auto Scaling は、*TestTable* にプロビジョンされた書き込み容量を調整できますが、容量単位は 5～10 の範囲内に限られます。

**注記**  
DynamoDB Auto Scaling では、ユーザーに代わって Auto Scaling アクションを実行する、サービスリンクロール (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) の存在を必要とします。このロールは自動的に作成されます。詳細については、*Application Auto Scaling ユーザーガイド*の「[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: スケーリングポリシーを作成する
<a name="AutoScaling.CLI.CreateScalingPolicy"></a>

このステップでは、`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 が 2 つの 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 に送る
<a name="AutoScaling.CLI.DriveTraffic"></a>

これで、`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 アクションを表示する
<a name="AutoScaling.CLI.ViewCWAlarms"></a>

 このステップでは、ユーザーに代わって開始された 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 が DynamoDB に `UpdateTable` リクエストを発行したことを示しています。

1. DynamoDB がテーブルの書き込み容量を増やしたことを確認するには、次のコマンドを入力します。

   ```
   aws dynamodb describe-table \
       --table-name TestTable \
       --query "Table.[TableName,TableStatus,ProvisionedThroughput]"
   ```

   `WriteCapacityUnits` は `5` から `10` にスケーリングされている必要があります。

## (オプション) ステップ 6: クリーンアップする
<a name="AutoScaling.CLI.CleanUp"></a>

このチュートリアルでは、いくつかのリソースを作成しました。これらのリソースが不要になった場合は、削除できます。

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 テーブルでの Auto Scaling の設定
<a name="AutoScaling.HowTo.SDK"></a>

AWS マネジメントコンソール と AWS Command Line Interface (AWS CLI) を使用するほかに、Amazon DynamoDB Auto Scaling とやり取りするアプリケーションを作成することもできます。このセクションには、この機能をテストするために使用できる 2 つの Java プログラムが含まれています。
+ `EnableDynamoDBAutoscaling.java`
+ `DisableDynamoDBAutoscaling.java`

## テーブルの Application Auto Scaling の有効化
<a name="AutoScaling.HowTo.SDK-enable"></a>

次のプログラムは、DynamoDB テーブル (`TestTable`) の Auto Scaling ポリシーをセットアップする例を示しています。プログラムの流れは次のようになります。
+ `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:
               <tableId> <roleARN> <policyName>\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<ScalingPolicy> 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 リソースネーム (ARN) を指定する必要があります。(例: `arn:aws:iam::122517410325:role/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`。) 次のプログラムの `SERVICE_ROLE_ARN_GOES_HERE` を実際の ARN に置き換えます。

```
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 の無効化
<a name="AutoScaling.HowTo.SDK-disable"></a>

次のプログラムは、前述のプロセスを元に戻します。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:
               <tableId> <policyName>\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());
		}

	}

}
```

------