As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Políticas de escalabilidade em etapas para o Application Auto Scaling
Uma política de escalabilidade por etapas dimensiona a capacidade do seu aplicativo em incrementos predefinidos com base em alarmes. CloudWatch É possível definir políticas de escalabilidade separadas para lidar com o aumento horizontal da escala (aumento da capacidade) e com a redução horizontal da escala (diminuição da capacidade) quando um limite de alarme é violado.
Com as políticas de escalabilidade por etapas, você cria e gerencia os CloudWatch alarmes que invocam o processo de escalabilidade. Quando um alarme é violado, o Application Auto Scaling inicia a política de escalabilidade associada a esse alarme.
A política de escalabilidade em etapas escala a capacidade usando um conjunto de ajustes, conhecidos como *ajustes de etapas*. A dimensão dos ajustes varia de acordo com a magnitude da violação do alarme.
+ Se a violação exceder o primeiro limite, o Application Auto Scaling aplicará o primeiro ajuste de etapa.
+ Se a violação exceder o segundo limite, o Application Auto Scaling aplicará o segundo ajuste de etapa, e assim por diante.
Isso permite que a política de escalabilidade responda adequadamente a alterações menores e maiores na métrica de alarme.
A política continuará a responder a violações de alarmes adicionais, mesmo enquanto uma atividade de escalabilidade estiver em andamento. Isso significa que o Application Auto Scaling avaliará todas as violações de alarmes à medida que ocorrerem. Um período de esfriamento é usado para obter proteção contra a escalabilidade excessiva devido a múltiplas violações de alarmes que ocorrem em rápida sucessão.
De forma semelhante ao rastreamento de destinos, a escalabilidade em etapas pode ajudar a escalar automaticamente a capacidade da aplicação à medida que ocorrem alterações no tráfego. No entanto, as políticas de rastreamento de destinos tendem a ser mais fáceis de implementar e gerenciar para necessidades constantes de escalabilidade.
**Destinos escaláveis compatíveis**
É possível usar políticas de escalabilidade em etapas com os seguintes destinos escaláveis:
+ WorkSpaces Frotas de aplicativos
+ clusters de bancos de dados Aurora
+ serviços da ECS
+ Clusters do EMR
+ SageMaker Variantes de endpoint de IA
+ SageMaker Componentes de inferência de IA
+ SageMaker Concorrência provisionada por IA sem servidor
+ Spot Fleets
+ Recursos personalizados
**Topics**
+ [Como funciona a escalabilidade em etapas](step-scaling-policy-overview.md)
+ [Criar uma política de escalabilidade em etapas](create-step-scaling-policy-cli.md)
+ [Descrever políticas de escalabilidade em etapas](describe-step-scaling-policy.md)
+ [Excluir política de escalabilidade em etapas](delete-step-scaling-policy.md)
# Como funciona a escalabilidade em etapas para o Application Auto Scaling
Este tópico descreve como a escalabilidade em etapas funciona e apresenta os principais elementos de uma política de escalabilidade em etapas.
**Topics**
+ [Como funcionam](#step-scaling-how-it-works)
+ [Ajustes em etapas](#as-scaling-steps)
+ [Tipos de ajuste da escalabilidade](#as-scaling-adjustment)
+ [Período de espera](#step-scaling-cooldown)
+ [Comandos normalmente usados](#step-scaling-policy-commonly-used-commands)
+ [Considerações](#step-scaling-considerations)
+ [Recursos relacionados](#step-scaling-related-resources)
+ [Acesso ao console](#step-scaling-console-access)
## Como funcionam
Para usar o escalonamento por etapas, você cria um CloudWatch alarme que monitora uma métrica para sua meta escalável. Defina a métrica, o valor limite e o número de períodos de avaliação que determinam uma violação de alarme. Além disso, você cria uma política de escalabilidade em etapas que define como escalar a capacidade quando o limite de alarme é violado e associá-la ao seu destino escalável.
Adicione os ajustes de etapas na política. É possível definir diferentes ajustes de etapas com base na dimensão da violação do alarme. Por exemplo:
+ Aumentar a escala horizontalmente em 10 unidades de capacidade, se a métrica de alarme atingir 60%.
+ Aumentar a escala horizontalmente em 30 unidades de capacidade, se a métrica de alarme atingir 75%.
+ Aumentar a escala horizontalmente em 40 unidades de capacidade, se a métrica de alarme atingir 85%.
Quando o limite de alarme for violado durante o número especificado de períodos de avaliação, o Application Auto Scaling aplicará os ajustes de etapas definidos na política. Os ajustes podem continuar para violações de alarmes adicionais até que o estado do alarme retorne a `OK`.
As atividades de escalabilidade são executadas com períodos de esfriamento entre elas para evitar flutuações rápidas na capacidade. Opcionalmente, é possível configurar os períodos de esfriamento para a política de escalabilidade.
## Ajustes em etapas
Ao criar uma política de escalabilidade em etapas, especifique um ou mais ajustes de etapa que ajustarão automaticamente a escala da capacidade do destino de maneira dinâmica com base no tamanho da violação do alarme. Cada ajuste em etapas especifica o seguinte:
+ Um limite inferior para o valor da métrica
+ Um limite superior para o valor da métrica
+ O valor de acordo com o qual dimensionar com base no tipo de ajuste de dimensionamento
CloudWatch agrega pontos de dados métricos com base na estatística da métrica associada ao seu CloudWatch alarme. Quando o alarme é violado, a política de dimensionamento apropriada é invocada. O Application Auto Scaling aplica seu tipo de agregação especificado aos pontos de dados métricos mais recentes de CloudWatch (em oposição aos dados métricos brutos). Ele compara esse valor de métrica agregada com os limites superior e inferior definidos pelo ajustes em etapa para determinar qual deles deve ser executado.
Você especifica os limites superior e inferior em relação ao limite de ruptura. Por exemplo, digamos que você tenha criado um CloudWatch alarme e uma política de expansão para quando a métrica estiver acima de 50%. Em seguida, você criou um segundo alarme e uma política para reduzir a escala horizontalmente em momentos em que a métrica está abaixo de 50%. Você definiu um conjunto de ajustes de etapas com um tipo de ajuste `PercentChangeInCapacity` para cada política:
**Exemplo: ajustes em etapas para política de expansão**
| **Limite inferior** | **Limite superior** | **Ajuste** |
| --- | --- | --- |
| 0 | 10 | 0 |
| 10 | 20 | 10 |
| 20 | nulo | 30 |
**Exemplo: ajustes em etapas para política de redução**
| **Limite inferior** | **Limite superior** | **Ajuste** |
| --- | --- | --- |
| -10 | 0 | 0 |
| -20 | -10 | -10 |
| nulo | -20 | -30 |
Isso cria a seguinte configuração de escalabilidade.
```
Metric value
-infinity 30% 40% 60% 70% infinity
-----------------------------------------------------------------------
-30% | -10% | Unchanged | +10% | +30%
-----------------------------------------------------------------------
```
Agora, suponhamos que você use essa configuração de escalabilidade em um destino escalável com uma capacidade de 10. Os pontos a seguir resumem o comportamento da configuração de escalabilidade em relação à capacidade do destino escalável:
+ A capacidade original será mantida enquanto o valor agregado da métrica for maior que 40 e menor que 60.
+ Se o valor da métrica chegar a 60, o Application Auto Scaling aumentará a capacidade do destino escalável em 1, totalizando 11. Isso é com base no segundo ajuste em etapas da política de expansão (adicionar 10% de 10). Depois de adicionar a nova capacidade, o Application Auto Scaling aumentará a capacidade atual para 11. Se o valor da métrica aumentar para 70 mesmo depois desse aumento da capacidade, o Application Auto Scaling aumentará a capacidade de destino em 3, totalizando 14. Isso é com base no terceiro ajuste em etapas da política de expansão (adicionar 30% de 11, 3,3, arredondado para 3).
+ Se o valor da métrica chegar a 40, o Application Auto Scaling diminuirá a capacidade do destino escalável em 1, para 13, com base na segunda etapa de ajuste da política de redução da escala na horizontal (remoção 10% de 14; ou seja 1,4 arredondado para 1). Se o valor da métrica cair para 30 mesmo após essa redução de capacidade, o Application Auto Scaling diminuirá a capacidade do destino em 3, para 10, com base no ajuste da terceira etapa da política de redução da escala na horizontal (remover 30% de 13, 3,9, arredondado para baixo, ou seja, para 3).
Ao especificar os ajustes em etapas para sua política de escalabilidade, observe o seguinte:
+ Os intervalos de seus ajustes em etapas não podem se sobrepor ou ter uma lacuna.
+ Somente um ajuste em etapas pode ter um limite inferior nulo (infinito negativo). Se um ajuste em etapas tiver um limite inferior negativo, não deverá haver um ajuste em etapas com um limite inferior nulo.
+ Somente um ajuste em etapas pode ter um limite superior nulo (infinito positivo). Se um ajuste em etapas tiver um limite superior positivo, deverá haver um ajuste em etapas com um limite superior nulo.
+ Os limites inferior e superior não podem ser nulos no mesmo ajuste em etapas.
+ Se o valor da métrica estiver acima do limite de violação, o limite inferior será inclusivo e o limite superior será exclusivo. Se o valor da métrica estiver abaixo do limite de violação, o limite inferior será exclusivo e o limite superior será inclusivo.
## Tipos de ajuste da escalabilidade
É possível definir uma política de escalabilidade que execute a ação de escalabilidade ideal, com base no tipo de ajuste de escalabilidade escolhido. É possível especificar o tipo de ajuste como uma porcentagem da capacidade atual do seu alvo escalável ou em números absolutos.
O Application Auto Scaling oferece suporte aos seguintes tipos de políticas de escalabilidade em etapas:
+ **ChangeInCapacity**—Aumente ou diminua a capacidade atual da meta escalável de acordo com o valor especificado. Um valor positivo aumenta a capacidade e um valor negativo diminui a capacidade. Por exemplo: se a capacidade atual for de 3 e o ajuste for 5, o Application Auto Scaling adicionará 5 à capacidade, totalizando 8.
+ **ExactCapacity**—Altere a capacidade atual do alvo escalável para o valor especificado. Especifique um valor não negativo com esse tipo de ajuste. Por exemplo: se a capacidade atual for de 3 e o ajuste for 5, o Application Auto Scaling alterará a capacidade para 5.
+ **PercentChangeInCapacity**—Aumente ou diminua a capacidade atual da meta escalável na porcentagem especificada. Um valor positivo aumenta a capacidade e um valor negativo diminui a capacidade. Por exemplo: se a capacidade atual for de 10 e o ajuste for 10%, o Application Auto Scaling adicionará 1 à capacidade, totalizando 11.
Se o valor resultante não for um inteiro, o Application Auto Scaling arredondará da seguinte forma:
+ Valores maiores que 1 serão arredondados para baixo. Por exemplo, `12.7` será arredondado para `12`.
+ Os valores entre 0 e 1 serão arredondados para 1. Por exemplo, `.67` será arredondado para `1`.
+ Os valores entre 0 e -1 serão arredondados para -1. Por exemplo, `-.58` será arredondado para `-1`.
+ Os valores menores que -1 serão arredondado para cima. Por exemplo, `-6.67` será arredondado para `-6`.
Com **PercentChangeInCapacity**, você também pode especificar o valor mínimo a ser escalado usando o `MinAdjustmentMagnitude` parâmetro. Por exemplo, suponha que você crie uma política que adiciona 25% e especifique, no mínimo, 2. Se o destino escalável tiver uma capacidade de 4 e a política de escalabilidade for realizada, 25% de 4 é 1. No entanto, como você especificou um incremento mínimo de 2, o Application Auto Scaling adicionará 2.
## Período de espera
Opcionalmente, você pode definir um período de esfriamento na política de escalação em etapas.
O período de esfriamento especifica quanto tempo a política de escalação espera até uma atividade anterior de escalação ter efeito.
Há duas maneiras de planejar o uso de períodos de esfriamento para uma configuração de escalação em etapas:
+ Com o período de esfriamento para políticas de aumento de escala horizontal, a intenção é aumentar a escala horizontalmente de modo contínuo (mas não excessivo). Depois que o Application Auto Scaling aumenta a escala horizontalmente com êxito usando uma política de escalação em etapas, ele começa a calcular o tempo de esfriamento. A política de escalação não aumentará a capacidade desejada novamente a menos que um aumento maior da escala horizontal seja disparado ou que o período de esfriamento termine. Enquanto o período de desaquecimento após expansão estiver em vigor, a capacidade adicionada pela ação de expansão de início será calculada como parte da capacidade desejada para a próxima ação de expansão.
+ Com o período de esfriamento para políticas de redução de escala horizontal, a intenção é reduzir de maneira conservadora para proteger a disponibilidade da aplicação, de modo que as ações de redução de escala horizontal fiquem bloqueadas até o período de esfriamento expirar. No entanto, se outro alarme acionar uma ação de ampliação durante o período de desaquecimento da redução da escala, o Application Auto Scaling expandirá o destino imediatamente. Nesse caso, o período de esfriamento da redução da escala horizontal é interrompido e não é concluído.
Por exemplo, quando ocorre um pico de tráfego, um alarme é disparado e o Application Auto Scaling automaticamente adiciona capacidade para ajudar a lidar com o aumento da carga. Se você definir um período de esfriamento para a política de aumento de escala horizontal, quando o alarme acionar a política para aumentar a capacidade em 2, a ação de escalação será concluída com sucesso e o período de esfriamento do aumento da escala horizontal será iniciado. Se o alarme disparar novamente durante período de esfriamento, mas com um ajuste em etapas mais agressivo de 3, o aumento de 2 anterior será considerado parte da capacidade atual. Portanto, apenas 1 será adicionado à capacidade. Isso permite uma escalação mais rápida do que esperar a expiração do esfriamento, mas sem adicionar mais capacidade do que o necessário.
O período de desaquecimento é medido em segundos e se aplica somente a ações de escalabilidade relacionadas à política. Durante um período de desaquecimento, quando uma ação programada começa no horário programado, ela pode acionar uma ação de escalabilidade imediatamente, sem esperar que o período de desaquecimento expire.
O valor padrão é 300 se nenhum valor for especificado.
## Comandos normalmente usados para criação, exclusão e gerenciamento de política de escalabilidade
Os comandos comumente usados para trabalhar com políticas de escalabilidade incluem:
+ [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)registrar AWS ou personalizar recursos como alvos escaláveis (um recurso que o Application Auto Scaling pode escalar) e suspender e retomar o escalonamento.
+ [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)para adicionar ou modificar políticas de escalabilidade para um alvo escalável existente.
+ [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)para retornar informações sobre atividades de escalabilidade em uma AWS região.
+ [describe-scaling-policies](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-policies.html)para retornar informações sobre políticas de escalabilidade em uma AWS região.
+ [delete-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scaling-policy.html)para excluir uma política de escalabilidade.
## Considerações
As considerações a seguir são aplicáveis ao trabalhar com políticas de escalabilidade em etapas:
+ Avalie se é possível prever os ajustes em etapas na aplicação com precisão suficiente para usar a escalabilidade em etapas. Se a métrica de escalabilidade aumentar ou diminuir proporcionalmente à capacidade do destino dimensionável, recomendamos que você use uma política de escalabilidade de rastreamento do objetivo. Você ainda tem a opção de usar a escalabilidade em etapas como política adicional para uma configuração mais avançada. Por exemplo, é possível configurar uma resposta mais agressiva quando a utilização atinge determinado nível.
+ Para evitar oscilações, certifique-se de escolher uma margem adequada entre os limites de redução e aumento da escala. Oscilação é um ciclo infinito de aumento e redução de escala horizontal. Ou seja, se o sistema adotar alguma ação de escalabilidade, o valor da métrica mudaria e iniciaria outra ação de escalabilidade na direção inversa.
## Recursos relacionados
Para obter mais informações sobre a criação de políticas de escalabilidade em etapas para grupos do Auto Scaling, consulte [Políticas de escalabilidade simples e em etapas para o Amazon EC2 Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scaling-simple-step.html) no *Guia do usuário do Amazon EC2 Auto Scaling*.
## Acesso ao console
O acesso ao console para visualizar, adicionar, atualizar ou remover políticas de escalabilidade em etapas nos recursos escaláveis depende do recurso utilizado. Para obter mais informações, consulte [Serviços da AWS que você pode usar com o Application Auto Scaling](integrated-services-list.md).
# Crie uma política de escalabilidade de etapas para o Application Auto Scaling usando o AWS CLI
Este exemplo usa AWS CLI comandos para criar uma política de escalabilidade por etapas para um serviço do Amazon ECS. Para usar um destino escalável diferente, especifique o respectivo namespace em `--service-namespace`, a dimensão escalável em `--scalable-dimension` e o ID do recurso em `--resource-id`.
Ao usar o AWS CLI, lembre-se de que seus comandos são Região da AWS executados no configurado para seu perfil. Se você deseja executar os comandos em uma região diferente, altere a região padrão para o seu perfil ou use o parâmetro `--region` com o comando.
**Topics**
+ [Etapa 1: registrar um destino escalável](#step-scaling-register-scalable-target)
+ [Etapa 2: criar uma política de escalabilidade em etapas](#create-step-scaling-policy)
+ [Etapa 3: criar um alarme que invoca uma política de escalabilidade](#step-scaling-create-alarm)
## Etapa 1: registrar um destino escalável
Se você ainda não tiver feito isso, inscreva o destino escalável. Use o [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)comando para registrar um recurso específico no serviço de destino como um alvo escalável. O exemplo a seguir inscreve um serviço do Amazon ECS com o Application Auto Scaling. O Application Auto Scaling pode escalar o número de tarefas em um mínimo de duas tarefas e um máximo de dez. Substitua cada *user input placeholder* por suas próprias informações.
**Linux, macOS ou Unix**
```
aws application-autoscaling register-scalable-target --service-namespace ecs \
--scalable-dimension ecs:service:DesiredCount \
--resource-id service/my-cluster/my-service \
--min-capacity 2 --max-capacity 10
```
**Windows**
```
aws application-autoscaling register-scalable-target --service-namespace ecs ^
--scalable-dimension ecs:service:DesiredCount ^
--resource-id service/my-cluster/my-service ^
--min-capacity 2 --max-capacity 10
```
**Output**
Se obtiver êxito, esse comando retornará o ARN do destino escalável. O seguinte é um exemplo de saída.
```
{
"ScalableTargetARN": "arn:aws:application-autoscaling:region:account-id:scalable-target/1234abcd56ab78cd901ef1234567890ab123"
}
```
## Etapa 2: criar uma política de escalabilidade em etapas
Para criar uma política de escalabilidade em etapas para um destino escalável, você pode usar os exemplos a seguir para começar.
------
#### [ Scale out ]
**Como criar uma política de escalabilidade em etapas para aumentar a escala horizontalmente (aumentar a capacidade)**
1. Use o comando `cat` a seguir para especificar uma configuração de política de escalabilidade em etapas em um arquivo JSON chamado `config.json` em seu diretório inicial. Veja a seguir um exemplo de configuração com um tipo de ajuste `PercentChangeInCapacity` que aumenta a capacidade do alvo escalável com base nos seguintes ajustes de etapa (assumindo um limite de CloudWatch alarme de 70):
+ Aumentar a capacidade em 10% quando o valor da métrica for maior ou igual a 70, mas menor que 85.
+ Aumentar a capacidade em 20% quando o valor da métrica for maior ou igual a 85, mas menor que 95.
+ Aumentar a capacidade em 30% quando o valor da métrica for maior ou igual a 95.
```
$ cat ~/config.json
{
"AdjustmentType": "PercentChangeInCapacity",
"MetricAggregationType": "Average",
"Cooldown": 60,
"MinAdjustmentMagnitude": 1,
"StepAdjustments": [
{
"MetricIntervalLowerBound": 0.0,
"MetricIntervalUpperBound": 15.0,
"ScalingAdjustment": 10
},
{
"MetricIntervalLowerBound": 15.0,
"MetricIntervalUpperBound": 25.0,
"ScalingAdjustment": 20
},
{
"MetricIntervalLowerBound": 25.0,
"ScalingAdjustment": 30
}
]
}
```
Para obter mais informações, consulte a Referência [StepScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_StepScalingPolicyConfiguration.html)da *API Application Auto Scaling*.
1. Use o [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)comando a seguir, junto com o `config.json` arquivo que você criou, para criar uma política de escalabilidade chamada`my-step-scaling-policy`.
**Linux, macOS ou Unix**
```
aws application-autoscaling put-scaling-policy --service-namespace ecs \
--scalable-dimension ecs:service:DesiredCount \
--resource-id service/my-cluster/my-service \
--policy-name my-step-scaling-policy --policy-type StepScaling \
--step-scaling-policy-configuration file://config.json
```
**Windows**
```
aws application-autoscaling put-scaling-policy --service-namespace ecs ^
--scalable-dimension ecs:service:DesiredCount ^
--resource-id service/my-cluster/my-service ^
--policy-name my-step-scaling-policy --policy-type StepScaling ^
--step-scaling-policy-configuration file://config.json
```
**Output**
O resultado inclui o ARN que serve como um nome exclusivo para a política. Você precisa dele para criar um CloudWatch alarme para sua política. O seguinte é um exemplo de saída.
```
{
"PolicyARN": "arn:aws:autoscaling:region:123456789012:scalingPolicy:ac542982-cbeb-4294-891c-a5a941dfa787:resource/ecs/service/my-cluster/my-service:policyName/my-step-scaling-policy"
}
```
------
#### [ Scale in ]
**Como criar uma política de escalabilidade em etapas para reduzir a escala horizontalmente (diminuir a capacidade)**
1. Use o comando `cat` a seguir para especificar uma configuração de política de escalabilidade em etapas em um arquivo JSON chamado `config.json` em seu diretório inicial. Veja a seguir um exemplo de configuração com um tipo de ajuste `ChangeInCapacity` que diminui a capacidade do alvo escalável com base nos seguintes ajustes de etapa (assumindo um limite de CloudWatch alarme de 50):
+ Diminuir a capacidade em 1 quando o valor da métrica é menor ou igual a 50, mas maior que 40.
+ Diminuir a capacidade em 2 quando o valor da métrica é menor ou igual a 40, mas maior que 30.
+ Diminuir a capacidade em 3 quando o valor da métrica é menor ou igual a 30.
```
$ cat ~/config.json
{
"AdjustmentType": "ChangeInCapacity",
"MetricAggregationType": "Average",
"Cooldown": 60,
"StepAdjustments": [
{
"MetricIntervalUpperBound": 0.0,
"MetricIntervalLowerBound": -10.0,
"ScalingAdjustment": -1
},
{
"MetricIntervalUpperBound": -10.0,
"MetricIntervalLowerBound": -20.0,
"ScalingAdjustment": -2
},
{
"MetricIntervalUpperBound": -20.0,
"ScalingAdjustment": -3
}
]
}
```
Para obter mais informações, consulte a Referência [StepScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_StepScalingPolicyConfiguration.html)da *API Application Auto Scaling*.
1. Use o [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)comando a seguir, junto com o `config.json` arquivo que você criou, para criar uma política de escalabilidade chamada`my-step-scaling-policy`.
**Linux, macOS ou Unix**
```
aws application-autoscaling put-scaling-policy --service-namespace ecs \
--scalable-dimension ecs:service:DesiredCount \
--resource-id service/my-cluster/my-service \
--policy-name my-step-scaling-policy --policy-type StepScaling \
--step-scaling-policy-configuration file://config.json
```
**Windows**
```
aws application-autoscaling put-scaling-policy --service-namespace ecs ^
--scalable-dimension ecs:service:DesiredCount ^
--resource-id service/my-cluster/my-service ^
--policy-name my-step-scaling-policy --policy-type StepScaling ^
--step-scaling-policy-configuration file://config.json
```
**Output**
O resultado inclui o ARN que serve como um nome exclusivo para a política. Você precisa desse ARN para criar um CloudWatch alarme para sua política. O seguinte é um exemplo de saída.
```
{
"PolicyARN": "arn:aws:autoscaling:region:123456789012:scalingPolicy:ac542982-cbeb-4294-891c-a5a941dfa787:resource/ecs/service/my-cluster/my-service:policyName/my-step-scaling-policy"
}
```
------
## Etapa 3: criar um alarme que invoca uma política de escalabilidade
Por fim, use o CloudWatch [put-metric-alarm](https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/put-metric-alarm.html)comando a seguir para criar um alarme para usar com sua política de escalabilidade de etapas. Neste exemplo, você tem um alarme com base na utilização média da CPU. O alarme é configurado para entrar em um estado de ALARME se atingir o limite de 70% por, no mínimo, dois períodos de avaliação consecutivos de 60 segundos. Para especificar uma CloudWatch métrica diferente ou usar sua própria métrica personalizada, especifique seu nome em `--metric-name` e seu namespace em. `--namespace`
**Linux, macOS ou Unix**
```
aws cloudwatch put-metric-alarm --alarm-name Step-Scaling-AlarmHigh-ECS:service/my-cluster/my-service \
--metric-name CPUUtilization --namespace AWS/ECS --statistic Average \
--period 60 --evaluation-periods 2 --threshold 70 \
--comparison-operator GreaterThanOrEqualToThreshold \
--dimensions Name=ClusterName,Value=default Name=ServiceName,Value=sample-app-service \
--alarm-actions PolicyARN
```
**Windows**
```
aws cloudwatch put-metric-alarm --alarm-name Step-Scaling-AlarmHigh-ECS:service/my-cluster/my-service ^
--metric-name CPUUtilization --namespace AWS/ECS --statistic Average ^
--period 60 --evaluation-periods 2 --threshold 70 ^
--comparison-operator GreaterThanOrEqualToThreshold ^
--dimensions Name=ClusterName,Value=default Name=ServiceName,Value=sample-app-service ^
--alarm-actions PolicyARN
```
# Descreva as políticas de escalabilidade de etapas para Application Auto Scaling usando o AWS CLI
Você pode descrever todas as políticas de escalabilidade para um namespace de serviço usando o comando. [describe-scaling-policies](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-policies.html) O exemplo a seguir descreve todas as políticas de escalabilidade para todos os serviços do Amazon ECS. Para listá-las para um serviço específico do Amazon ECS, adicione apenas a opção `--resource-id`.
```
aws application-autoscaling describe-scaling-policies --service-namespace ecs
```
Você pode filtrar os resultados apenas para as políticas de escalabilidade em etapas usando o parâmetro `--query`. Para mais informações sobre a sintaxe de `query`, consulte [Controlar a saída do comando da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-output.html) no *Manual do usuário da AWS Command Line Interface *.
**Linux, macOS ou Unix**
```
aws application-autoscaling describe-scaling-policies --service-namespace ecs \
--query 'ScalingPolicies[?PolicyType==`StepScaling`]'
```
**Windows**
```
aws application-autoscaling describe-scaling-policies --service-namespace ecs ^
--query "ScalingPolicies[?PolicyType==`StepScaling`]"
```
**Output**
O seguinte é um exemplo de saída.
```
[
{
"PolicyARN": "PolicyARN",
"StepScalingPolicyConfiguration": {
"MetricAggregationType": "Average",
"Cooldown": 60,
"StepAdjustments": [
{
"MetricIntervalLowerBound": 0.0,
"MetricIntervalUpperBound": 15.0,
"ScalingAdjustment": 1
},
{
"MetricIntervalLowerBound": 15.0,
"MetricIntervalUpperBound": 25.0,
"ScalingAdjustment": 2
},
{
"MetricIntervalLowerBound": 25.0,
"ScalingAdjustment": 3
}
],
"AdjustmentType": "ChangeInCapacity"
},
"PolicyType": "StepScaling",
"ResourceId": "service/my-cluster/my-service",
"ServiceNamespace": "ecs",
"Alarms": [
{
"AlarmName": "Step-Scaling-AlarmHigh-ECS:service/my-cluster/my-service",
"AlarmARN": "arn:aws:cloudwatch:region:012345678910:alarm:Step-Scaling-AlarmHigh-ECS:service/my-cluster/my-service"
}
],
"PolicyName": "my-step-scaling-policy",
"ScalableDimension": "ecs:service:DesiredCount",
"CreationTime": 1515024099.901
}
]
```
# Exclua uma política de escalabilidade de etapas para o Application Auto Scaling usando o AWS CLI
Quando você não precisar mais de uma política de dimensionamento em etapas, poderá excluí-la. Para excluir a política de escalabilidade e o CloudWatch alarme associado, conclua as tarefas a seguir.
**Para excluir a política de dimensionamento**
Use o comando [delete-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scaling-policy.html).
**Linux, macOS ou Unix**
```
aws application-autoscaling delete-scaling-policy --service-namespace ecs \
--scalable-dimension ecs:service:DesiredCount \
--resource-id service/my-cluster/my-service \
--policy-name my-step-scaling-policy
```
**Windows**
```
aws application-autoscaling delete-scaling-policy --service-namespace ecs ^
--scalable-dimension ecs:service:DesiredCount ^
--resource-id service/my-cluster/my-service ^
--policy-name my-step-scaling-policy
```
**Para excluir o CloudWatch alarme**
Use o comando [delete-alarms](https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/delete-alarms.html). É possível excluir um ou mais alarmes por vez. Por exemplo, use o comando a seguir para excluir os alarmes `Step-Scaling-AlarmHigh-ECS:service/my-cluster/my-service` e `Step-Scaling-AlarmLow-ECS:service/my-cluster/my-service`.
```
aws cloudwatch delete-alarms --alarm-name Step-Scaling-AlarmHigh-ECS:service/my-cluster/my-service Step-Scaling-AlarmLow-ECS:service/my-cluster/my-service
```