# Usar a AWS CLI para gerenciar o Auto Scaling do Amazon DynamoDB
Em vez de usar o Console de gerenciamento da AWS, você pode usar a AWS Command Line Interface (AWS CLI) para gerenciar o Auto Scaling do Amazon DynamoDB. O tutorial desta seção demonstra como instalar e configurar a AWS CLI para gerenciar o Auto Scaling do DynamoDB. Neste tutorial, você faz o seguinte:
+ Crie uma tabela do DynamoDB chamada `TestTable`. As configurações de throughput iniciais são 5 unidades de capacidade de leitura e 5 unidades de capacidade de gravação.
+ Crie uma política do Application Auto Scaling para `TestTable`. A política procura manter uma taxa de destino de 50% entre a capacidade de gravação consumida e a capacidade de gravação provisionada. O intervalo dessa métrica é entre 5 e 10 unidades de capacidade de gravação. (O Application Auto Scaling não tem permissão para ajustar o throughput além desse intervalo.)
+ Execute um programa Python para direcionar o tráfego de gravação para `TestTable`. Quando a taxa pretendida ultrapassar 50% por período contínuo, o Application Auto Scaling notificará o DynamoDB para aumentar o throughput de `TestTable` para que os 50% da utilização pretendida possam ser mantidos.
+ Verifique se o DynamoDB ajustou com sucesso a capacidade de gravação provisionada de `TestTable`.
**nota**
Também é possível programar o ajuste de escala do DynamoDB para que ele ocorra em determinados horários. Conheça as etapas básicas [aqui](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html).
**Topics**
+ [Antes de começar](#AutoScaling.CLI.BeforeYouBegin)
+ [Etapa 1: Crie uma tabela do DynamoDB](#AutoScaling.CLI.CreateTable)
+ [Etapa 2: registrar uma capacidade pretendida escalável](#AutoScaling.CLI.RegisterScalableTarget)
+ [Etapa 3: criar uma política de dimensionamento](#AutoScaling.CLI.CreateScalingPolicy)
+ [Etapa 4: direcionar o tráfego de gravação para TestTable](#AutoScaling.CLI.DriveTraffic)
+ [Etapa 5: visualizar ações do Application Auto Scaling](#AutoScaling.CLI.ViewCWAlarms)
+ [Etapa 6 (opcional): limpar](#AutoScaling.CLI.CleanUp)
## Antes de começar
Antes de iniciar o tutorial, é necessário concluir as tarefas a seguir.
### Instalar o AWS CLI
Caso ainda não tenha feito isso, você deve instalar e configurar a AWS CLI. Para fazer isso, siga estas instruções no *Guia do usuário do AWS Command Line Interface*:
+ [Instalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)
+ [Configurando a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
### Instalar o Python
Parte deste tutorial requer que você execute um programa Python (consulte [Etapa 4: direcionar o tráfego de gravação para TestTable](#AutoScaling.CLI.DriveTraffic)). Caso ainda não esteja instalado, você poderá [fazer download do Python](https://www.python.org/downloads).
## Etapa 1: Crie uma tabela do DynamoDB
Nesta etapa, use a AWS CLI para criar uma `TestTable`. A chave primária de `pk` consiste em (chave de partição) e `sk` (chave de classificação). Ambos os atributos são do tipo `Number`. As configurações de throughput iniciais são 5 unidades de capacidade de leitura e 5 unidades de capacidade de gravação.
1. Use o comando AWS CLI a seguir para criar a tabela:
```
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. Para verificar o status da tabela, use o comando a seguir.
```
aws dynamodb describe-table \
--table-name TestTable \
--query "Table.[TableName,TableStatus,ProvisionedThroughput]"
```
A tabela está pronta para uso quando seu status é `ACTIVE`.
## Etapa 2: registrar uma capacidade pretendida escalável
Agora você registrará a capacidade de gravação da tabela como uma capacidade pretendida escalável com o Application Auto Scaling. Isso permite que o Application Auto Scaling ajuste a capacidade de gravação provisionada de *TestTable*, mas apenas no intervalo de 5 a 10 unidades de capacidade.
**nota**
O Auto Scaling do DynamoDB requer a presença de uma função vinculada ao serviço (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) que realize ações de Auto Scaling em seu nome. Esta função é criada automaticamente para você. Para ter mais informações, consulte [Funções vinculadas a serviço do Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html), no *Guia do usuário do Application Auto Scaling*.
1. Agora, insira o comando a seguir para registrar a capacidade pretendida.
```
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. Para verificar o registro, use o comando a seguir:
```
aws application-autoscaling describe-scalable-targets \
--service-namespace dynamodb \
--resource-id "table/TestTable"
```
**nota**
Você também pode registrar um valor pretendido escalável em relação a um índice secundário global. Por exemplo, em um índice secundário global (“test-index”), o ID do recurso e os argumentos de dimensão escalável são atualizados adequadamente.
```
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
```
## Etapa 3: criar uma política de dimensionamento
Nesta etapa, você cria uma política de escalabilidade para `TestTable`. A política define os detalhes sob os quais o Application Auto Scaling pode ajustar o throughput provisionado da tabela e as ações que serão executadas quando ele fizer isso. Você associa essa política à capacidade pretendida que definiu na etapa anterior (unidades de capacidade de gravação da tabela `TestTable`).
A política contém os elementos a seguir:
+ `PredefinedMetricSpecification`: a métrica que o Application Auto Scaling tem permissão para ajustar. Para o DynamoDB, os valores a seguir são válidos para `PredefinedMetricType`:
+ `DynamoDBReadCapacityUtilization`
+ `DynamoDBWriteCapacityUtilization`
+ `ScaleOutCooldown`: a quantidade mínima de tempo (em segundos) entre cada evento do Application Auto Scaling que aumenta o throughput provisionado. Esse parâmetro permite que o Application Auto Scaling aumente o throughput de forma contínua, mas não agressivamente, em resposta às workloads do mundo real. A configuração padrão de `ScaleOutCooldown` é 0.
+ `ScaleInCooldown`: a quantidade mínima de tempo (em segundos) entre cada evento do Application Auto Scaling que diminui o throughput provisionado. Esse parâmetro permite que o Application Auto Scaling diminua o throughput de forma gradual e previsível. A configuração padrão de `ScaleInCooldown` é 0.
+ `TargetValue`: o Application Auto Scaling garante que o índice de capacidade consumida para capacidade provisionada permaneça nesse valor ou próximo a ele. Você define `TargetValue` como uma porcentagem.
**nota**
Para compreender melhor como o `TargetValue` funciona, suponha que você tenha uma tabela com uma configuração de throughput provisionado de 200 unidades de capacidade de gravação. Você decide criar uma política de dimensionamento para essa tabela, com um `TargetValue` de 70%.
Agora, suponha que você comece a direcionar tráfego de gravação para a tabela de forma que o throughput de gravação real seja de 150 unidades de capacidade. A taxa consumida-para-provisionada agora é (150/200), ou 75%. Essa taxa excede o valor pretendido. Portanto, o Application Auto Scaling aumenta a capacidade de gravação provisionada para 215 de modo que a taxa seja (150/215) ou 69,77% — tão próxima ao seu `TargetValue` quanto possível, mas sem excedê-lo.
Para `TestTable`, defina `TargetValue` como 50%. O Application Auto Scaling ajusta o throughput provisionado da tabela dentro do intervalo de 5 a 10 unidades de capacidade (consulte [Etapa 2: registrar uma capacidade pretendida escalável](#AutoScaling.CLI.RegisterScalableTarget)) para que a taxa consumida-para-provisionada permaneça em 50% ou próxima a isso. Você define os valores de `ScaleOutCooldown` e `ScaleInCooldown` para 60 segundos.
1. Crie um arquivo denominado `scaling-policy.json` com os conteúdos a seguir.
```
{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "DynamoDBWriteCapacityUtilization"
},
"ScaleOutCooldown": 60,
"ScaleInCooldown": 60,
"TargetValue": 50.0
}
```
1. Use o comando da AWS CLI a seguir para criar a política.
```
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. Na saída, observe que o Application Auto Scaling criou dois alarmes do Amazon CloudWatch: um para o limite superior e outro para o limite inferior da faixa de escalabilidade prevista.
1. Use o comando da AWS CLI a seguir para visualizar mais detalhes sobre a política de escalabilidade.
```
aws application-autoscaling describe-scaling-policies \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--policy-name "MyScalingPolicy"
```
1. Na saída, verifique se as configurações da política correspondem às suas especificações de [Etapa 2: registrar uma capacidade pretendida escalável](#AutoScaling.CLI.RegisterScalableTarget) e [Etapa 3: criar uma política de dimensionamento](#AutoScaling.CLI.CreateScalingPolicy).
## Etapa 4: direcionar o tráfego de gravação para TestTable
Agora, você pode testar a política de escalabilidade gravando dados em `TestTable`. Para fazer isso, execute um programa Python.
1. Crie um arquivo denominado `bulk-load-test-table.py` com os conteúdos a seguir.
```
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. Para executar o programa, insira o comando a seguir.
`python bulk-load-test-table.py`
A capacidade de gravação provisionada de `TestTable` é muito baixa (5 unidades de capacidade de gravação), para que o programa pare ocasionalmente devido a limitações de gravação. Esse comportamento é esperado.
Deixe o programa continuar em execução enquanto você avança para a próxima etapa.
## Etapa 5: visualizar ações do Application Auto Scaling
Nesta etapa, você visualiza as ações do Application Auto Scaling que são iniciadas em seu nome. Você também pode verificar se o Application Auto Scaling atualizou a capacidade de gravação provisionada de `TestTable`.
1. Insira o comando a seguir para visualizar as ações do Application Auto Scaling.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace dynamodb
```
Execute esse comando ocasionalmente, enquanto o programa Python está em execução. (Alguns minutos serão necessários antes que sua política de escalabilidade seja invocada.) Você deve finalmente ver a saída a seguir.
```
...
{
"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"
},
...
```
Isso indica que o Application Auto Scaling emitiu uma solicitação `UpdateTable` para o DynamoDB.
1. Digite o comando a seguir para verificar se o DynamoDB aumentou a capacidade de gravação da tabela.
```
aws dynamodb describe-table \
--table-name TestTable \
--query "Table.[TableName,TableStatus,ProvisionedThroughput]"
```
As `WriteCapacityUnits` devem ter sido dimensionadas de `5` para `10`.
## Etapa 6 (opcional): limpar
Neste tutorial, você criou vários recursos. Você pode excluir esses recursos se eles não forem mais necessários.
1. Excluir a política de escalabilidade de `TestTable`.
```
aws application-autoscaling delete-scaling-policy \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits" \
--policy-name "MyScalingPolicy"
```
1. Cancelar o registro de capacidade pretendida escalável.
```
aws application-autoscaling deregister-scalable-target \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits"
```
1. Exclua a tabela `TestTable`.
```
aws dynamodb delete-table --table-name TestTable
```