# DynamoDB Auto Scaling을 사용하여 자동으로 처리량 용량 관리
많은 데이터베이스 워크로드는 본질적으로 주기적인 반면 다른 워크로드는 미리 예측하기 어렵습니다. 낮 시간 동안에는 대부분의 사용자가 활성 상태인 소셜 네트워킹 앱을 한 가지 예로 들어 보겠습니다. 이러한 데이터베이스에서는 주간 활동을 처리할 수 있어야 하지만, 밤에는 동일한 수준의 처리량이 필요 없습니다. 예상치 못한 빠른 속도로 도입 중인 새로운 모바일 게임 앱을 또 다른 예로 들 수 있습니다. 이 게임의 인기가 너무 높아지면 사용 가능한 데이터베이스 리소스 양을 초과하여 성능이 느려지고 고객 불만이 발생할 것입니다. 이러한 종류의 워크로드는 대개 사용량 변화에 따라 수동 개입을 통해 데이터베이스 리소스의 규모를 늘리거나 줄여야 합니다.
Amazon DynamoDB Auto Scaling은 AWS Application Auto Scaling 서비스를 사용하여 프로비저닝된 처리 능력을 실제 트래픽 패턴에 따라 사용자 대신 동적으로 조정합니다. 따라서 테이블 또는 글로벌 보조 인덱스(GSI)에 따라 할당된 읽기 및 쓰기 용량을 늘려 제한 없이 갑작스러운 트래픽 증가를 처리할 수 있습니다. 워크로드가 감소할 경우 Application Auto Scaling은 사용하지 않는 프로비저닝된 용량에 대한 요금을 지불하지 않도록 처리량을 줄일 수 있습니다.
**참고**
AWS Management Console을 사용하여 테이블이나 글로벌 보조 인덱스를 생성한 경우 DynamoDB Auto Scaling이 기본적으로 활성화됩니다. 언제든지 Auto Scaling 설정을 변경할 수 있습니다. 자세한 내용은 [DynamoDB Auto Scaling에서 AWS Management Console 사용](AutoScaling.Console.md) 섹션을 참조하세요.
테이블 또는 글로벌 테이블 복제본을 삭제하면 연결된 확장 가능한 대상, 확장 정책 또는 CloudWatch 경보가 자동으로 삭제되지 않습니다.
Application Auto Scaling을 사용하여 테이블 또는 글로벌 보조 인덱스의 *크기 조정 정책*을 생성합니다. 이 규모 조정 정책을 통해 읽기 용량이나 쓰기 용량(또는 둘 다)을 조정할 것인지 여부와 테이블 또는 인덱스에 대해 할당된 용량 단위의 최댓값 및 최솟값 설정을 지정할 수 있습니다.
크기 조정 정책에는 특정 시점에 소비된 프로비저닝된 처리량의 비율인 *목표 사용률*도 포함됩니다. Application Auto Scaling은 *목표 추적* 알고리즘을 사용하여 실제 워크로드에 따라 테이블(또는 인덱스)의 프로비저닝된 처리량을 위나 아내로 조정하여 실제 용량 사용률이 목표 사용률 값이나 그에 가까운 수준으로 유지되도록 합니다.
DynamoDB 출력은 1분 동안 프로비저닝된 처리량을 소비했습니다. Auto Scaling은 소비된 용량이 구성된 목표 사용률을 2분 연속으로 초과할 때 트리거됩니다. CloudWatch 경보가 Auto Scaling을 트리거하기 전에 최대 몇 분의 짧은 지연이 있을 수 있습니다. 이러한 지연을 통해 정확한 CloudWatch 지표 평가가 이루어집니다. 하지만 소비된 처리량의 급증 간격이 1분보다 크면 Auto Scaling이 트리거되지 않을 수 있습니다. 마찬가지로 15개의 연속 데이터 포인트가 목표 사용률보다 낮을 때 스케일 다운 이벤트가 발생할 수 있습니다. 두 경우 모두 Auto Scaling이 트리거된 후 [UpdateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html)가 간접적으로 호출됩니다. 그런 다음 테이블 또는 인덱스의 프로비저닝된 용량을 업데이트하는 데 몇 분 정도 걸립니다. 이 기간 동안 테이블의 이전 프로비저닝된 용량을 초과하는 모든 요청은 제한됩니다.
**중요**
위반할 데이터 포인트 수를 조정하여 기본 경보를 트리거할 수는 없습니다(현재 숫자는 향후 변경될 수 있음).
읽기 및 쓰기 용량에 대해 20%와 90% 사이에서 Auto Scaling 목표 사용률 값을 설정할 수 있습니다.
**참고**
DynamoDB Auto Scaling은 테이블 외에 글로벌 보조 인덱스도 지원합니다. 모든 글로벌 보조 인덱스에는 기본 테이블과 별도로 자체 프로비저닝된 처리 능력이 있습니다. 글로벌 보조 인덱스에 대한 크기 조정 정책을 생성하면 Application Auto Scaling은 해당 인덱스의 프로비저닝된 처리량 설정을 조절하여 실제 사용률이 원하는 사용률이나 그에 가깝게 유지되도록 합니다.
## DynamoDB Auto Scaling 작동 방식
**참고**
DynamoDB Auto Scaling을 빠르게 시작하려면 [DynamoDB Auto Scaling에서 AWS Management Console 사용](AutoScaling.Console.md) 섹션을 참조하세요.
아래 그림에는 DynamoDB Auto Scaling이 테이블의 처리 용량을 관리하는 방법이 간단히 소개되어 있습니다.
![\[DynamoDB Auto Scaling은 수요에 맞게 테이블의 처리량 용량을 조정합니다.\]](http://docs.aws.amazon.com/ko_kr/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 1,200개 범위에서 목표 사용률 70%면 `ProductCatalog` 테이블에 적당하다고 결정합니다. *목표 사용률*이란 프로비저닝된 용량 단위에 대한 소비된 용량 단위의 비율을 백분율로 나타낸 값입니다. Application Auto Scaling은 목표 추적 알고리즘을 사용하여 `ProductCatalog`의 프로비저닝된 읽기 용량을 필요에 따라 조절함으로써 사용률이 70% 안팎으로 유지되도록 합니다.
**참고**
DynamoDB Auto Scaling은 실제 워크로드가 일정 시간(분) 동안 높게 또는 낮게 유지되는 경우에 한해 프로비저닝된 처리량(throughput) 설정을 수정합니다. Application Auto Scaling의 목표 추적 알고리즘은 목표 사용률을 장기적으로 사용자가 선택한 값 안팎으로 유지되도록 합니다.
짧은 기간 동안 갑자기 급증하는 활동은 테이블에 기본 제공되는 버스트 용량으로 처리합니다. 자세한 내용은 [버스트 용량](burst-adaptive-capacity.md#burst-capacity) 섹션을 참조하세요.
`ProductCatalog` 테이블에 대해 DynamoDB Auto Scaling을 활성화하기 위해 크기 조정 정책을 만듭니다. 이 정책은 다음을 지정합니다.
+ 관리하려는 테이블 또는 글로벌 보조 인덱스
+ 관리하려는 용량 유형(읽기 용량 또는 쓰기 용량)
+ 프로비저닝된 처리량 설정의 상한값과 하한값
+ 목표 사용률
크기 조정 정책이 생성되면 Application Auto Scaling은 사용자 대신 Amazon CloudWatch 경보 쌍을 생성합니다. 각 쌍은 할당된 처리량(throughput) 설정의 상한값과 하한값을 나타냅니다. 테이블의 실제 사용률이 일정한 시간 동안 목표 사용률을 벗어나면 이러한 CloudWatch 경보가 트리거됩니다.
CloudWatch 경보 중 하나가 트리거되면 Amazon SNS에서 알림을 보냅니다(알림을 활성화한 경우). 그러면 CloudWatch 경보가 Application Auto Scaling을 호출하고, 여기서 다시 DynamoDB에 알려 `ProductCatalog` 테이블의 프로비저닝된 용량을 적절히 상향 또는 하향 조정하도록 합니다.
규모 조정 이벤트 중에 AWS Config에는 기록된 구성 항목당 요금이 부과됩니다. 규모 조정 이벤트가 발생하면 각 읽기 및 쓰기 Auto Scaling 이벤트에 대해 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)에서 기본 단계를 알아보세요.
## 사용 노트
DynamoDB Auto Scaling을 사용하려면 먼저 다음 내용을 이해해야 합니다.
+ DynamoDB Auto Scaling은 Auto Scaling 정책에 따라 필요한 만큼 자주 읽기 용량이나 쓰기 용량을 늘릴 수 있습니다. 모든 DynamoDB 할당량은 [Amazon DynamoDB의 할당량](ServiceQuotas.md)에서 설명한 것처럼 계속 유효합니다.
+ DynamoDB Auto Scaling은 프로비저닝된 처리량 설정을 사용자가 수동으로 수정하는 것도 허용합니다. 이러한 수동 조정은 DynamoDB Auto Scaling과 관련된 기존의 CloudWatch 경보에는 영향을 주지 않습니다.
+ 글로벌 보조 인덱스가 하나 이상인 테이블에 대해 DynamoDB Auto Scaling을 활성화하는 경우, 해당 인덱스에도 Auto Scaling을 균일하게 적용하는 것이 좋습니다. 이를 통해 테이블 쓰기 및 읽기 성능이 향상되고 제한을 방지할 수 있습니다. AWS Management Console에서 **Apply same settings to global secondary indexes**(글로벌 보조 인덱스에 동일한 설정 적용)를 선택하여 Auto Scaling을 사용하도록 설정할 수 있습니다. 자세한 내용은 [기존 테이블에서 DynamoDB Auto Scaling 활성화](AutoScaling.Console.md#AutoScaling.Console.ExistingTable) 섹션을 참조하세요.
+ 테이블 또는 전역 테이블 복제본을 삭제하면 연결된 확장 가능한 대상, 확장 정책 또는 CloudWatch 경보가 자동으로 삭제되지 않습니다.
+ 기존 테이블에 대한 GSI를 생성할 때 GSI에 대해 Auto Scaling이 활성화되지 않습니다. GSI 빌드 중에는 용량을 수동으로 관리해야 합니다. GSI의 백필이 완료되고 활성 상태에 도달하면 Auto Scaling이 정상적으로 작동합니다.
# DynamoDB Auto Scaling에서 AWS Management Console 사용
AWS Management Console을 사용하여 새 테이블을 생성할 경우, 해당 테이블에 대해 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에 대한 권한 부여
AWS Identity and Access Management(IAM)에서 AWS 관리형 정책 `DynamoDBFullAccess`는 DynamoDB 콘솔을 사용하는 데 필요한 권한을 제공합니다. 하지만 DynamoDB Auto Scaling의 경우에는 사용자에게 몇 가지 권한이 추가로 필요합니다.
**중요**
Auto scaling이 활성화된 테이블을 삭제하려면 `application-autoscaling:*` 권한이 필요합니다. AWS 관리형 정책인 `DynamoDBFullAccess`에 그러한 권한이 포함되어 있습니다.
DynamoDB 콘솔 액세스 및 DynamoDB Auto Scaling의 사용자를 설정하려면 역할을 생성하고 **AmazonDynamoDBFullAccess** 정책을 해당 역할에 추가합니다. 그런 다음 사용자에게 역할을 할당합니다.
## Auto Scaling을 활성화하여 새 테이블 만들기
**참고**
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. **기본 설정**을 선택하면 새 테이블에서 Auto Scaling이 활성화됩니다.
또는 **설정 사용자 지정**을 선택한 후 다음을 수행하여 테이블에 대한 사용자 지정 설정을 지정합니다.
1. **테이블 클래스**에서 **DynamoDB Standard**의 기본 선택을 유지합니다.
1. **읽기/쓰기 용량 설정**에서 기본 선택인 **프로비저닝됨**을 유지하고 다음을 수행합니다.
1. **읽기 용량**에서 **Auto Scaling**을 **켜기**로 설정해야 합니다.
1. **읽기 용량**에서 **Auto Scaling**을 **켜기**로 설정해야 합니다.
1. **읽기 용량** 및 **쓰기 용량**에 대해 테이블에 원하는 크기 조정 정책을 설정하고 선택적으로 테이블의 모든 글로벌 보조 인덱스를 설정합니다.
+ **최소 용량 단위** - Auto Scaling 범위의 하한값을 입력합니다.
+ **최대 용량 단위** - Auto Scaling 범위의 상한값을 입력합니다.
+ **목표 사용률** - 테이블의 목표 사용률을 입력합니다.
**참고**
새 테이블에 대한 글로벌 보조 인덱스를 생성하는 경우 생성 시 인덱스의 용량은 기본 테이블의 용량과 동일합니다. 테이블을 만든 후 테이블 설정에서 인덱스의 용량을 변경할 수 있습니다.
1. **테이블 생성**을 선택합니다. 지정한 Auto Scaling 파라미터로 테이블이 생성됩니다.
## 기존 테이블에서 DynamoDB Auto Scaling 활성화
**참고**
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. Auto Scaling을 활성화하려는 테이블을 선택한 후 다음을 수행합니다.
1. **추가 설정** 탭으로 이동합니다.
1. **읽기/쓰기 용량** 섹션에서 **편집**을 선택합니다.
1. **용량 모드** 섹션에서 **프로비저닝됨**을 선택합니다.
1. **테이블 용량** 섹션에서 **읽기 용량**, **쓰기 용량** 또는 양쪽 모두에 대해 **오토 스케일링**링을 **켜기**로 설정합니다. 이러한 각 항목에 대해 테이블에 원하는 크기 조정 정책을 설정하고 선택적으로 테이블의 모든 글로벌 보조 인덱스를 설정합니다.
+ **최소 용량 단위** - Auto Scaling 범위의 하한값을 입력합니다.
+ **최대 용량 단위** - Auto Scaling 범위의 상한값을 입력합니다.
+ **목표 사용률** - 테이블의 목표 사용률을 입력합니다.
+ **모든 글로벌 보조 인덱스에 대해 동일한 용량 읽기/쓰기 용량 설정 사용** - 글로벌 보조 인덱스에서 기본 테이블과 동일한 Auto Scaling 정책을 사용할지 여부를 선택합니다.
**참고**
최상의 성능을 내려면 **글로벌 보조 인덱스에 동일한 설정 적용(Use the same read/write capacity settings for all global secondary indexes)**을 활성화하는 것이 좋습니다. 이 옵션을 사용하면 DynamoDB Auto Scaling에서 기본 테이블의 모든 글로벌 보조 인덱스를 균일하게 조정할 수 있습니다. 기존 글로벌 보조 인덱스와 향후 이 테이블에 대해 생성하는 모든 인덱스에 적용됩니다.
이 옵션을 활성화하면 개별 글로벌 보조 인덱스에 대해 크기 조정 정책을 설정할 수 없습니다.
1. 원하는 대로 설정되었으면 [**Save**]를 선택합니다.
## 콘솔에서 Auto Scaling 활동 보기
애플리케이션에서 해당 테이블에 대해 읽기 및 쓰기 트래픽을 구동할 경우 DynamoDB Auto Scaling은 테이블의 처리량 설정을 동적으로 수정합니다. Amazon CloudWatch는 모든 DynamoDB 테이블 및 보조 인덱스에 대한 프로비저닝되고 사용된 용량, 제한 이벤트, 지연 시간 및 기타 지표를 추적합니다.
DynamoDB 콘솔에서 이러한 지표를 보려면 작업할 테이블을 선택하고 **모니터링** 탭을 선택합니다. 테이블 지표의 사용자 지정 가능한 보기를 만들려면 **CloudWatch에서 모두 보기(View all in CloudWatch)**를 선택합니다.
## DynamoDB Auto Scaling 설정 수정 또는 비활성화
AWS Management Console을DynamoDB 사용하여 Auto Scaling 설정을 수정할 수 있습니다. 이렇게 하려면 테이블의 **추가 설정** 탭으로 이동하여 **읽기/쓰기 용량** 섹션에서 **편집**을 선택합니다. 이러한 설정에 대한 자세한 내용은 [기존 테이블에서 DynamoDB Auto Scaling 활성화](#AutoScaling.Console.ExistingTable) 섹션을 참조하세요.
# AWS CLI를 사용하여 DynamoDB Auto Scaling 관리
AWS Management Console을 사용하는 대신 AWS Command Line Interface(AWS CLI)를 사용하여 Amazon DynamoDB Auto Scaling을 관리할 수 있습니다. 이 섹션의 자습서에서는 DynamoDB Auto Scaling을 관리할 수 있도록 AWS CLI를 설치 및 구성하는 방법을 보여 줍니다. 이 자습서에서는 다음을 수행합니다.
+ `TestTable`이라는 DynamoDB 테이블을 생성합니다. 이 테이블의 초기 처리량 설정은 읽기 용량 단위 5, 쓰기 용량 단위 5입니다.
+ `TestTable`에 대한 Application Auto Scaling 정책을 생성합니다. 정책은 사용된 쓰기 용량과 할당된 쓰기 용량 사이의 비율이 50퍼센트 목표 비율이 되도록 유지하려 합니다. 이 수치의 범위는 쓰기 용량 단위 5-10입니다. (Application Auto Scaling은 이 범위를 초과하여 처리량을 조정할 수 없습니다.)
+ Python 프로그램을 실행하여 `TestTable`에 대해 쓰기 트래픽을 실행합니다. 목표 비율이 장기적으로 50퍼센트를 초과할 경우 Application Auto Scaling은 목표 사용률의 50퍼센트가 유지될 수 있도록 DynamoDB에 `TestTable` 처리량을 상향 조정하도록 알립니다.
+ 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\$110으로 제한됩니다.
**참고**
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단계: 크기 조정 정책 생성
이 단계에서는 `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\$110의 범위 내에서 조정([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로 쓰기 트래픽 유도
이제 `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로 매우 낮아서 쓰기 조절(throttling)로 인해 프로그램이 때때로 중단됩니다. 이는 예상된 동작입니다.
다음 단계로 이동하여 프로그램이 지속적으로 실행될 수 있도록 해 보겠습니다.
## 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이 DynamoDB에 `UpdateTable` 요청을 보냈음을 나타냅니다.
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 테이블에서 Auto Scaling 구성
AWS Management Console 및 AWS Command Line Interface(AWS CLI)를 사용하는 방법 외에 Amazon DynamoDB Auto Scaling과 상호 작용하는 애플리케이션을 작성할 수도 있습니다. 이 섹션에서는 이 기능을 테스트하는 데 사용할 수 있는 2가지 Java 프로그램이 나와 있습니다.
+ `EnableDynamoDBAutoscaling.java`
+ `DisableDynamoDBAutoscaling.java`
## 테이블에 대해 Application Auto Scaling 활성화
다음 프로그램은 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:
\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 서비스 연결 역할의 Armazon 리소스 이름(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 비활성화
다음 프로그램은 이전 프로세스를 반대로 수행합니다. 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());
}
}
}
```
------