# Gerenciar a capacidade de throughput automaticamente com o ajuste de escala automático do DynamoDB Muitas workloads de banco de dados são cíclicas por natureza, enquanto outras são difíceis de prever com antecedência. Por exemplo, considere um aplicativo de rede social na qual a maioria dos usuários está ativa durante o horário diurno. O banco de dados deve ser capaz de lidar com a atividade durante o dia, mas não há necessidade dos mesmos níveis de throughput à noite. Outro exemplo: considere um novo aplicativo de jogos para celular que está sendo adotado de maneira rápida e inesperada. Se o jogo se tornar muito comum, talvez ele exceda os recursos de banco de dados disponíveis, resultando em performance lenta e clientes insatisfeitos. Esses tipos de workloads muitas vezes exigem intervenção manual para dimensionar recursos de banco de dados, aumentando-os ou diminuindo-os em resposta a diferentes níveis de uso. O Auto Scaling do Amazon DynamoDB usa o serviço AWS Application Auto Scaling para ajustar dinamicamente a capacidade de throughput provisionado em seu nome em resposta aos padrões de tráfego reais. Isso permite que uma tabela ou um índice secundário global (GSI) aumente a capacidade provisionada de leitura e de gravação para processar aumentos repentinos no tráfego, sem controle de utilização. Quando a workload diminuir, o Application Auto Scaling diminuirá o throughput para que você não precise pagar por uma capacidade provisionada não utilizada. **nota** Se você usar o Console de gerenciamento da AWS para criar uma tabela ou um índice secundário global, o Auto Scaling do DynamoDB será habilitado por padrão. É possível modificar as configurações de Auto Scaling a qualquer momento. Para obter mais informações, consulte [Usar o Console de gerenciamento da AWS com o Auto Scaling do DynamoDB](AutoScaling.Console.md). Ao remover manualmente uma tabela ou uma réplica de tabela global, você não remove automaticamente as metas escaláveis associadas, as políticas de escalabilidade nem os alarmes do CloudWatch. Com o Application Auto Scaling, você cria um *política de escalabilidade* para uma tabela ou um índice secundário global. A política de escalabilidade especifica se você deseja dimensionar a capacidade de leitura ou a capacidade de gravação (ou ambas), bem como as configurações mínimas e máximas de unidades de capacidade provisionadas para a tabela ou o índice. A política de escalabilidade também contém uma *utilização pretendida*: o percentual de throughput provisionado consumida em um determinado ponto no tempo. O Application Auto Scaling usa um *algoritmo de rastreamento* para ajustar o throughput provisionado da tabela (ou índice) para cima ou para baixo em resposta a workloads reais para que a utilização da capacidade real permaneça em ou perto de sua utilização pretendida. As saídas do DynamoDB consumiram o throughput provisionado por períodos de um minuto. O ajuste de escala automático é acionado quando a capacidade consumida ultrapassa a meta de utilização configurada em dois minutos consecutivos. Os alarmes do CloudWatch podem ter um pequeno atraso de até alguns minutos antes de acionar o ajuste de escala automático. Esse atraso garante uma avaliação precisa da métrica do CloudWatch. Se os picos de throughput consumidos tiverem mais de um minuto de intervalo, o ajuste de escala automático poderá não ser acionado. Da mesma forma, um evento de redução de escala verticalmente pode ocorrer quando 15 pontos de dados consecutivos estão abaixo da meta de utilização. Nos dois casos, depois que o ajuste de escala automático é acionado, a API [UpdateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html) é invocada. Depois, leva alguns minutos para atualizar a capacidade provisionada da tabela ou do índice. Durante esse período, todas as solicitações que excederem a capacidade provisionada anterior das tabelas terão controle de utilização. **Importante** Não é possível ajustar o número de pontos de dados a serem violados antes do acionamento do alarme subjacente (embora o número atual possa mudar no futuro). É possível definir os valores de utilização do destino de Auto Scaling entre 20% e 90% como sua capacidade de gravação e leitura. **nota** Além de tabelas, o Auto Scaling do DynamoDB também oferece suporte a índices secundários globais. Cada índice secundário global tem sua própria capacidade de throughput provisionado separadamente daquela da tabela-base. Quando você cria uma política de escalabilidade para um índice secundário global, o Application Auto Scaling ajusta as configurações de throughput provisionado do índice para garantir que sua utilização real permaneça em ou perto da proporção de utilização desejada. ## Como o Auto Scaling do DynamoDB funciona **nota** Para começar a trabalhar rapidamente com o Auto Scaling do DynamoDB, consulte [Usar o Console de gerenciamento da AWS com o Auto Scaling do DynamoDB](AutoScaling.Console.md). O diagrama a seguir fornece uma visão geral de alto nível de como o Auto Scaling do DynamoDB gerencia a capacidade de throughput de uma tabela. ![\[O ajuste de escala automático do DynamoDB ajusta a capacidade de throughput de uma tabela para atender à demanda.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/auto-scaling.png) As etapas a seguir resumem o processo de Auto Scaling, conforme mostrado no diagrama anterior: 1. Você cria uma política do Application Auto Scaling para sua tabela do DynamoDB. 1. O DynamoDB publica métricas de capacidade consumida no Amazon CloudWatch. 1. Se a capacidade consumida da tabela exceder sua utilização pretendida (ou cair abaixo do valor desejado) por um período específico, o Amazon CloudWatch disparará um alarme. Você pode visualizar o alarme no console receber notificações por SMS usando o Amazon Simple Notification Service (Amazon SNS). 1. O alarme do CloudWatch invoca o Application Auto Scaling para avaliar sua política de escalabilidade. 1. O Application Auto Scaling emite uma solicitação `UpdateTable` para ajustar o throughput provisionado da sua tabela. 1. O DynamoDB processa a solicitação `UpdateTable`, aumentando (ou diminuindo) dinamicamente a capacidade de throughput provisionado da tabela de forma que ela se aproxime da sua utilização pretendida. Para entender como o Auto Scaling do DynamoDB funciona, suponha que você tenha uma tabela chamada `ProductCatalog`. A tabela é raramente carregada em massa com dados e, por isso, não provoca muita atividade de gravação. No entanto, ela é submetida a um alto grau de atividades de leitura, que variam ao longo do tempo. Ao monitorar as métricas do Amazon CloudWatch para o `ProductCatalog`, você determina que a tabela requer 1.200 unidades de capacidade de leitura (para evitar que o controle de utilização do DynamoDB leia solicitações durante picos de atividades). Você também determina que o `ProductCatalog` requer no mínimo 150 unidades de capacidade de leitura quando o tráfego de leitura está em seu ponto mais baixo. Para obter mais informações sobre como evitar o controle de utilização, consulte [Solução de problemas de controle de utilização no Amazon DynamoDB](TroubleshootingThrottling.md). No intervalo de 150 a 1.200 unidades de capacidade de leitura, você decide que uma utilização de destino de 70% seria apropriada para a tabela `ProductCatalog`. A *utilização pretendida* é a proporção entre unidades de capacidade consumidas e unidades de capacidade provisionadas, expressa como um percentual. O Application Auto Scaling usa seu algoritmo de rastreamento de capacidade pretendida para garantir que a capacidade de leitura provisionada de `ProductCatalog` seja ajustada conforme o necessário para que a utilização permaneça em ou perto de 70%. **nota** A autoescalabilidade do DynamoDB modifica as configurações de throughput provisionado somente quando a workload real permanece elevada ou baixa por um período constante de vários minutos. O algoritmo de rastreamento de alvo do Application Auto Scaling procura manter a utilização pretendida em ou perto do seu valor escolhido em longo prazo. Picos de atividade súbitos de curta duração são acomodados pela capacidade de expansão interna da tabela. Para obter mais informações, consulte [Capacidade de expansão](burst-adaptive-capacity.md#burst-capacity). Para habilitar o Auto Scaling do DynamoDB para a tabela `ProductCatalog`, você cria uma política de escalabilidade. A política especifica o seguinte: + A tabela ou o índice secundário global que você deseja gerenciar + Qual tipo de capacidade gerenciar (capacidade de leitura ou capacidade de gravação) + Os limites superior e inferior das configurações de throughput provisionado + Utilização de destino Quando você criar uma política de escalabilidade, o Application Auto Scaling cria um par de alarmes do Amazon CloudWatch em seu nome. Cada par representa os limites superiores e inferiores das configurações de throughput provisionado. Esses alarmes do CloudWatch são disparados quando a utilização real da tabela se desvia da utilização pretendida por um período prolongado. Quando um dos alarmes do CloudWatch for disparado, o Amazon SNS enviará uma notificação (caso você tenha habilitado esse recurso). O alarme do CloudWatch chama o Application Auto Scaling, que, por sua vez, notifica o DynamoDB para ajustar a capacidade provisionada da tabela `ProductCatalog` para cima ou para baixo conforme apropriado. Durante um evento de ajuste de escala, o AWS Config é cobrado por item de configuração registrado. Quando ocorre um evento de ajuste de escala, quatro alarmes do CloudWatch são criados para cada evento de ajuste de escala automático de leitura e gravação: alarmes ProvisionedCapacity (ProvisionedCapacityLow e ProvisionedCapacityHigh) e alarmes ConsumedCapacity (AlarmHigh e AlarmLow). Isso soma um total de oito alarmes. Portanto, o AWS Config registra oito itens de configuração para cada evento de ajuste de escala. **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). ## Observações de uso Antes de começar a usar o Auto Scaling do DynamoDB, você deve estar ciente do seguinte: + O Auto Scaling do DynamoDB pode aumentar a capacidade de leitura ou gravação sempre que necessário, de acordo com a sua política de Auto Scaling. Todas as cotas do DynamoDB permanecem em vigor, conforme descrito em [Cotas no Amazon DynamoDB](ServiceQuotas.md). + O Auto Scaling do DynamoDB não impede a modificação manual de configurações de throughput provisionado. Esses ajustes manuais não afetam alarmes existentes do CloudWatch que estejam relacionados ao Auto Scaling do DynamoDB. + Se você habilitar o Auto Scaling do DynamoDB para uma tabela que tenha um ou mais índices secundários globais, é altamente recomendável que você também aplique o Auto Scaling uniformemente e esses índices. Isso ajudará a garantir uma performance melhor para gravações e leituras de tabelas e ajudará a evitar o controle de utilização. É possível habilitar a autoescalabilidade selecionando **Apply same settings to global secondary indexes** (Aplicar as mesmas configurações a índices secundários globais) no Console de gerenciamento da AWS. Para obter mais informações, consulte [Habilitar o Auto Scaling do DynamoDB em tabelas existentes](AutoScaling.Console.md#AutoScaling.Console.ExistingTable). + Ao remover manualmente uma tabela ou uma réplica de tabela global, você não remove automaticamente as metas escaláveis associadas, as políticas de dimensionamento nem os alarmes do CloudWatch. + Ao criar um GSI para uma tabela existente, o Auto Scaling não está habilitado para GSI. Você terá que gerenciar manualmente a capacidade enquanto o GSI está sendo compilado. Quando o provisionamento no GSI for concluído e atingir o status ativo, a autoescalabilidade funcionará normalmente. # Usar o Console de gerenciamento da AWS com o Auto Scaling do DynamoDB Quando você usa o Console de gerenciamento da AWS para criar uma nova tabela, o Auto Scaling do Amazon DynamoDB é habilitado para essa tabela por padrão. Você também pode usar o console para habilitar o Auto Scaling de tabelas existentes, modificar as configurações de Auto Scaling ou desabilitar o Auto Scaling. **nota** Para obter recursos mais avançados, como a definição de redução e expansão de períodos de cooldown, use a AWS Command Line Interface (AWS CLI) para gerenciar o dimensionamento automático do DynamoDB. Para obter mais informações, consulte [Usar a AWS CLI para gerenciar o Auto Scaling do Amazon DynamoDB](AutoScaling.CLI.md). **Topics** + [Antes de começar: concessão de permissões de usuário ao Auto Scaling do DynamoDB](#AutoScaling.Permissions) + [Criar uma nova tabela com Auto Scaling habilitado](#AutoScaling.Console.NewTable) + [Habilitar o Auto Scaling do DynamoDB em tabelas existentes](#AutoScaling.Console.ExistingTable) + [Visualizar atividades de Auto Scaling no console](#AutoScaling.Console.ViewingActivities) + [Modificar ou desabilitar configurações de Auto Scaling do DynamoDB](#AutoScaling.Console.Modifying) ## Antes de começar: concessão de permissões de usuário ao Auto Scaling do DynamoDB No AWS Identity and Access Management (IAM), a política `DynamoDBFullAccess`, gerenciada pela AWS, fornece as permissões necessárias para usar o console do DynamoDB. No entanto, para a autoescalabilidade do DynamoDB, os usuários precisam de permissões adicionais. **Importante** Para excluir uma tabela habilitada para ajuste de escala automático, são necessárias permissões `application-autoscaling:*`. A política `DynamoDBFullAccess`, gerenciada pela AWS, inclui essas permissões. Para configurar um usuário para acesso ao console do DynamoDB e autoescalabilidade do DynamoDB, crie um perfil e adicione a política **AmazonDynamoDBFullAccess** a esse perfil. Depois, atribua o perfil a um usuário. ## Criar uma nova tabela com Auto Scaling habilitado **nota** A autoescalabilidade do DynamoDB requer a presença de um perfil vinculado ao serviço (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) que realize ações de auescalabilidade em seu nome. Esta função é criada automaticamente para você. Para ter mais informações, consulte [Service-linked roles for Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html), no *Manual do usuário do Application Auto Scaling*. **Para criar uma nova tabela com Auto Scaling habilitada** 1. Abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/). 1. Escolha **Create table**. 1. Na página **Criar tabela**, insira o **Nome de tabela** e os detalhes da chave primária. 1. Se você escolher **Configurações padrão**, o ajuste de escala automático será ativado na nova tabela. Caso contrário, selecione **Personalizar configurações** e faça o seguinte para especificar configurações personalizadas para a tabela: 1. Em **Classe de tabela**, mantenha a seleção padrão do **DynamoDB Standard**. 1. Em **Configurações da capacidade de leitura/gravação**, mantenha a seleção padrão de **Provisionado** e faça o seguinte: 1. Em **Capacidade de leitura**, verifique se o **Ajuste de escala automático** está definido como **Ativado**. 1. Em **Capacidade de gravação**, verifique se o **Ajuste de escala automático** está definido como **Ativado**. 1. Em **Capacidade de leitura** e **Capacidade de gravação**, defina a política de escalabilidade desejada para a tabela e, opcionalmente, todos os índices secundários globais da tabela. + **Unidades de capacidade mínima**: insira o limite inferior para o intervalo de autoescalabilidade. + **Unidades de capacidade máxima**: insira o limite superior para o intervalo de autoescalabilidade. + **Utilização pretendida**: insira a porcentagem de utilização pretendida para a tabela. **nota** Se você criar um índice secundário global para a nova tabela, a capacidade do índice no momento da criação será a mesma da capacidade da tabela base. Você pode alterar a capacidade do índice nas configurações da tabela depois de criar a tabela. 1. Escolha **Criar tabela**. Isso cria a tabela com os parâmetros de ajuste de escala automático especificados. ## Habilitar o Auto Scaling do DynamoDB em tabelas existentes **nota** A autoescalabilidade do DynamoDB requer a presença de um perfil vinculado ao serviço (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) que realize ações de auescalabilidade em seu nome. Esta função é criada automaticamente para você. Para obter mais informações, consulte[ Funções vinculadas ao serviço para o Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html). **Para habilitar o Auto Scaling do DynamoDB para uma tabela existente** 1. Abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/). 1. No painel de navegação, no lado esquerdo do console, selecione **Tables** (Tabelas). 1. Selecione a tabela na qual você deseja habilitar o ajuste de escala automático e, depois, faça o seguinte: 1. Selecione a guia **Configurações adicionais**. 1. Na seção **Capacidade de leitura/gravação**, selecione **Editar**. 1. Na seção **Modo de capacidade**, selecione **Provisionada**. 1. Na seção **Capacidade da tabela**, deixe **Ajuste de escala automático** no modo **Ativado** para **Capacidade de leitura**, **Capacidade de gravação** ou ambos. Para cada um deles, defina a política de escalabilidade desejada para a tabela e, opcionalmente, todos os índices secundários globais da tabela. + **Unidades de capacidade mínima**: insira o limite inferior para o intervalo de autoescalabilidade. + **Unidades de capacidade máxima**: insira o limite superior para o intervalo de autoescalabilidade. + **Utilização pretendida**: insira a porcentagem de utilização pretendida para a tabela. + **Usar as mesmas configurações de capacidade de leitura/gravação para todos os índices secundários globais**: escolha se os índices secundários globais devem usar a mesma política de autoescalabilidade que a tabela de base. **nota** Para obter uma melhor performance, recomendamos habilitar **Use the same read/write capacity settings for all global secondary indexes (Usar as mesmas configurações de capacidade de leitura/gravação para todos os índices secundários globais).** Essa opção permite que o Auto Scaling do DynamoDB dimensione uniformemente todos os índices secundários globais na tabela-base. Isso inclui índices secundários globai existentes e quaisquer outros que você crie no futuro para essa tabela. Com essa opção habilitada, não é possível definir uma política de escalabilidade em um índice secundário global individual. 1. Quando estiver satisfeito com as configurações, clique em **Salvar**. ## Visualizar atividades de Auto Scaling no console À medida que a sua aplicação direciona tráfego de leitura e gravação para a sua tabela, o Auto Scaling do DynamoDB modifica dinamicamente as configurações de throughput da tabela. O Amazon CloudWatch acompanha a capacidade provisionada e consumida, eventos limitados, latência e outras métricas para todas as tabelas do DynamoDB e índices secundários. Para visualizar essas métricas no console do DynamoDB, escolha a tabela com a qual você deseja trabalhar e selecione a guia **Monitor**. Para criar uma visualização personalizável das métricas de tabela, selecione **View all in CloudWatch (Visualizar tudo no CloudWatch)**. ## Modificar ou desabilitar configurações de Auto Scaling do DynamoDB É possível usar o Console de gerenciamento da AWS para modificar configurações de Auto Scaling do DynamoDB. Para fazer isso, vá até a guia **Configurações adicionais** referente à sua tabela e selecione **Editar** na seção **Capacidade de leitura/gravação**. Para ter mais informações sobre essas configurações, consulte [Habilitar o Auto Scaling do DynamoDB em tabelas existentes](#AutoScaling.Console.ExistingTable). # 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 ``` # Usar o AWS SDK para configurar o Auto Scaling em tabelas do Amazon DynamoDB Além de usar o Console de gerenciamento da AWS e a AWS Command Line Interface (AWS CLI), você pode escrever aplicações que interagem com o Auto Scaling do Amazon DynamoDB. Esta seção contém dois programas Java que podem ser usados para testar essa funcionalidade: + `EnableDynamoDBAutoscaling.java` + `DisableDynamoDBAutoscaling.java` ## Habilitação do Application Auto Scaling para uma tabela O programa a seguir mostra um exemplo de configuração de uma política de Auto Scaling para uma tabela do DynamoDB (`TestTable`). Ele procede da seguinte maneira: + O programa registra unidades de capacidade de gravação como um destino dimensionável para a `TestTable`. O intervalo dessa métrica é entre 5 e 10 unidades de capacidade de gravação. + Depois que o destino escalável é criado, o programa cria uma configuração de rastreamento de destino. 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. + Em seguida, o programa cria a política de escalabilidade com base na configuração de rastreamento de destino. **nota** Ao remover manualmente uma tabela ou uma réplica de tabela global, você não remove automaticamente os destinos escaláveis associados, políticas de escalabilidade nem alarmes do 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 ] O programa exige que você forneça um nome do recurso da Amazon (ARN) para uma função vinculada ao serviço Application Auto Scaling válida. (Por exemplo: `arn:aws:iam::122517410325:role/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`.) No seguinte programa, substitua `SERVICE_ROLE_ARN_GOES_HERE` pelo ARN real. ``` 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()); } } } ``` ------ ## Desabilitar o Application Auto Scaling para uma tabela O programa a seguir inverte o processo anterior. Ele remove a política de Auto Scaling e cancela o registro do destino dimensionável. ------ #### [ 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()); } } } ``` ------