# Administración automática de la capacidad de rendimiento con la función Auto Scaling de DynamoDB Muchas cargas de trabajo de base de datos son de naturaleza cíclica, mientras que otras son difíciles de predecir con antelación. Por ejemplo, tomemos una aplicación de redes sociales en la que la mayoría de los usuarios están activos en el horario diurno. La base de datos debe satisfacer los requisitos de la actividad diurna, pero no se requieren los mismos niveles de rendimiento por la noche. Otro ejemplo: tomemos una nueva aplicación de juegos para móviles cuya adopción está siendo inesperadamente rápida. Si el juego adquiere demasiada popularidad, podría superar los recursos disponibles en la base de datos, lo que daría lugar a un rendimiento lento y a clientes descontentos. Estos tipos de cargas de trabajo suelen requerir intervención manual para escalar los recursos de la base de datos en sentido ascendente o descendente en respuesta a las variaciones en los niveles de uso. El escalado automático de Amazon DynamoDB usa el servicio Auto Scaling de aplicaciones de AWS para ajustar de manera dinámica y automática la capacidad de rendimiento aprovisionada en respuesta a los patrones de tráfico reales. Esto permite a una tabla o índice secundario global (GSI) incrementar su capacidad de lectura y escritura aprovisionada para abastecer incrementos repentinos del tráfico sin limitaciones. Cuando la carga de trabajo disminuye, el Auto Scaling de aplicaciones puede reducir el rendimiento para evitar que tenga que pagar por una capacidad aprovisionada que no se utiliza. **nota** Si usa la Consola de administración de AWS para crear una tabla o un índice secundario global, la función Auto Scaling de DynamoDB se habilita de forma predeterminada. Puede modificar los ajustes de Auto Scaling en cualquier momento. Para obtener más información, consulte [Uso de la Consola de administración de AWS con la función Auto Scaling de DynamoDB](AutoScaling.Console.md). Cuando elimina una tabla o una réplica de tabla global, los destinos escalables, las políticas de escalado o las alarmas de CloudWatch asociadas no se eliminan automáticamente con ella. Con Auto Scaling de aplicaciones, puede crear una *política de escalado* para una tabla o un índice secundario global. La política de escalado especifica si desea escalar la capacidad de lectura o de escritura (o ambas), así como los ajustes de unidades de capacidad provisionada mínimas y máximas para la tabla o el índice. La política de escalado contiene además un valor de *objetivo de utilización*, es decir, el porcentaje de rendimiento aprovisionado consumido en un momento dado. Auto Scaling de aplicaciones utiliza un algoritmo de *seguimiento de destino* para ajustar el rendimiento aprovisionado de la tabla (o el índice) al alza o a la baja en respuesta a las cargas de trabajo reales, de tal forma que la utilización de la capacidad real se mantenga en valores iguales o parecidos al objetivo de utilización. Las salidas de DynamoDB consumieron el rendimiento aprovisionado durante periodos de un minuto. El escalado automático se activa cuando la capacidad consumida supera el objetivo de utilización configurado durante dos minutos consecutivos. Es posible que las alarmas de CloudWatch tarden unos minutos antes de desencadenar el escalado automático. Este retraso garantiza una evaluación precisa de las métricas de CloudWatch. Si los picos de rendimiento consumidos están separados por más de un minuto, es posible que no se desencadene el escalado automático. Del mismo modo, se puede producir un evento de reducción vertical cuando 15 puntos de datos consecutivos sean inferiores a la utilización objetivo. En cualquier caso, tras desencadenar el escalado automático, se invoca la API [UpdateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html). La actualización de la capacidad aprovisionada para la tabla o el índice puede tardar unos minutos. Durante este periodo, cualquier solicitud que supere la capacidad aprovisionada previamente de las tablas se limita. **importante** No se puede ajustar el número de puntos de datos que se van a violar para desencadenar la alarma subyacente (aunque el número actual podría cambiar en el futuro). Puede establecer los valores de objetivo de utilización de escalado automático entre un 20 y un 90 por ciento de la capacidad de lectura y escritura. **nota** Además de con las tablas, el escalado automático de DynamoDB es compatible con los índices secundarios globales. Cada índice secundario global tiene su propia capacidad de rendimiento aprovisionada que es independiente de la de su tabla base. Al crear una política de escalado para un índice secundario global, Auto Scaling de aplicaciones ajusta los ajustes de rendimiento aprovisionado del índice para asegurarse de que el uso real se mantenga en valores iguales o parecidos al porcentaje de utilización deseado. ## Funcionamiento de la función Auto Scaling de DynamoDB **nota** Para comenzar rápidamente a usar la función Auto Scaling de DynamoDB, consulte [Uso de la Consola de administración de AWS con la función Auto Scaling de DynamoDB](AutoScaling.Console.md). En el siguiente diagrama se ofrece información general sobre cómo el escalado automático de DynamoDB administra la capacidad de rendimiento de una tabla. ![\[El escalado automático de DynamoDB ajusta la capacidad de rendimiento de una tabla para satisfacer la demanda.\]](http://docs.aws.amazon.com/es_es/amazondynamodb/latest/developerguide/images/auto-scaling.png) En los pasos siguientes se resume el proceso de Auto Scaling mostrado en el diagrama anterior: 1. Cree una política de Auto Scaling de aplicaciones para la tabla de DynamoDB. 1. DynamoDB publica métricas de capacidad consumida en Amazon CloudWatch. 1. Si la capacidad consumida de la tabla supera el objetivo de utilización (o no lo alcanza) durante un periodo de tiempo específico, Amazon CloudWatch activa una alarma. Puede ver la alarma en la consola y recibir notificaciones mediante Amazon Simple Notification Service (Amazon SNS). 1. La alarma de CloudWatch invoca a Auto Scaling de aplicaciones para evaluar la política de escalado. 1. Auto Scaling de aplicaciones emite una solicitud `UpdateTable` para ajustar el rendimiento aprovisionado de la tabla. 1. DynamoDB procesa la solicitud `UpdateTable` y aumenta (o reduce) dinámicamente la capacidad de rendimiento aprovisionada de la tabla para que sea parecida al objetivo de utilización. Para comprender cómo funciona el escalado automático de DynamoDB, supongamos que tenemos una tabla denominada `ProductCatalog`. Es infrecuente que se realicen cargas masivas de datos en la tabla, de modo que presenta poca actividad de escritura. Sin embargo, sí experimenta una intensa actividad de lectura, que varía en cada momento. Gracias a las métricas de Amazon CloudWatch de `ProductCatalog` que se monitorean, ha determinado que la tabla requiere 1 200 unidades de capacidad de lectura (para evitar que DynamoDB aplique una limitación controlada a las solicitudes de lectura durante los picos de actividad). También ha determinado que `ProductCatalog` requiere como mínimo 150 unidades de capacidad de lectura, cuando el tráfico de lectura se encuentra en el punto más bajo. Para obtener más información sobre cómo prevenir la limitación, consulte [Solución de problemas de limitación en Amazon DynamoDB](TroubleshootingThrottling.md). Dentro del rango de 150 a 1200 unidades de capacidad de lectura, decide que un objetivo de utilización del 70 por ciento sería apropiado para la tabla `ProductCatalog`. El *objetivo de utilización* es la proporción de unidades de capacidad consumidas respecto de las unidades de capacidad provisionadas y se expresa como un porcentaje. Auto Scaling de aplicaciones utiliza el algoritmo de seguimiento de destino para asegurarse de que la capacidad de lectura provisionada de `ProductCatalog` se ajuste de acuerdo con las necesidades, de tal forma que la utilización permanezca próxima al 70 %. **nota** La función de escalado automático de DynamoDB modifica la configuración de rendimiento aprovisionado solo cuando la carga de trabajo real se mantiene elevada o reducida durante un periodo sostenido de varios minutos. El algoritmo de seguimiento de destino de Auto Scaling de aplicaciones intenta mantener el objetivo de utilización en el valor elegido o en valores próximos a él a largo plazo. Los picos de actividad repentinos y breves se atienden gracias a la capacidad de ampliación incorporada de la tabla. Para obtener más información, consulte [Capacidad de ampliación](burst-adaptive-capacity.md#burst-capacity). Para habilitar el escalado automático de DynamoDB para la tabla `ProductCatalog`, debe crear una política de escalado. La política especifica los elementos siguientes: + La tabla o el índice secundario global que desea administrar + Qué tipo de capacidad va a administrar (capacidad de lectura o capacidad de escritura) + Los límites superior e inferior de los ajustes de desempeño provisionado + Su objetivo de utilización Al crear una política de escalado, Auto Scaling de aplicaciones crea automáticamente un par de alarmas de Amazon CloudWatch. Cada par representa los límites superior e inferior de la configuración de rendimiento provisionado. Estas alarmas de CloudWatch se activan cuando la utilización real de la tabla se desvía del objetivo de utilización durante un periodo de tiempo prolongado. Cuando se activa una de las alarmas de CloudWatch, Amazon SNS envía una notificación (si se ha habilitado). A continuación, la alarma de CloudWatch invoca a Auto Scaling de aplicaciones que, a su vez, notifica a DynamoDB para que ajuste la capacidad aprovisionada de la tabla `ProductCatalog` al alza o a la baja, según corresponda. Durante un evento de escalado, la AWS Config se cobra por cada elemento de configuración registrado. Cuando se produce un evento de escalado, se crean cuatro alarmas de CloudWatch para cada evento de escalado automático de lectura y escritura: alarmas ProvisionedCapacity: ProvisionedCapacityLow, ProvisionedCapacityHigh y alarmas ConsumedCapacity: AlarmHigh, AlarmLow. Esto da como resultado un total de ocho alarmas. Por lo tanto, AWS Config registra ocho elementos de configuración para cada evento de escalado. **nota** También puede programar el escalado de DynamoDB para que se realice en determinados momentos. Descubra los pasos básicos [aquí](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html). ## Notas de uso Antes de comenzar a usar la función Auto Scaling de DynamoDB, debe tener en cuenta lo siguiente: + La función Auto Scaling de DynamoDB puede aumentar la capacidad de lectura o escritura tan a menudo como sea preciso, de acuerdo con la política de Auto Scaling. Todas las cuotas de DynamoDB siguen vigentes, tal como se describe en [Cuotas en Amazon DynamoDB](ServiceQuotas.md). + La función Auto Scaling de DynamoDB no le impide modificar manualmente la configuración de rendimiento aprovisionado. Estos ajustes manuales no afectan a las alarmas de CloudWatch vigentes relacionadas con la función Auto Scaling de DynamoDB. + Si habilita la función Auto Scaling de DynamoDB en una tabla que tiene uno o varios índices secundarios globales, recomendamos encarecidamente aplicar también Auto Scaling de manera uniforme a esos índices. Esto contribuirá a garantizar un mejor rendimiento en las escrituras y lecturas de las tablas, y a evitar la limitación. Puede activar el escalado automático si selecciona **Apply same settings to global secondary indexes** (Aplicar la misma configuración a los índices secundarios globales) en la Consola de administración de AWS. Para obtener más información, consulte [Habilitación de la función Auto Scaling de DynamoDB en tablas existentes](AutoScaling.Console.md#AutoScaling.Console.ExistingTable). + Cuando elimina una tabla o una réplica de tabla global, los destinos escalables, las políticas de escalado o las alarmas de CloudWatch asociadas no se eliminan automáticamente con ella. + Al crear un GSI para una tabla existente, la función Auto Scaling no está habilitada para el GSI. Tendrá que administrar manualmente la capacidad mientras se construye el GSI. Una vez que se complete el relleno del GSI y este alcance el estado activo, la función de escalado automático funcionará con normalidad. # Uso de la Consola de administración de AWS con la función Auto Scaling de DynamoDB Si usa la Consola de administración de AWS para crear una tabla nueva, la función Auto Scaling de Amazon DynamoDB se habilita para esa tabla de forma predeterminada. También puede utilizar la consola para habilitar Auto Scaling en las tablas existentes, modificar la configuración de esta función o deshabilitarla. **nota** Para obtener carácterísticas más avanzadas como la configuración de tiempos de recuperación de escalado y reducción horizontal, utilice la AWS Command Line Interface (AWS CLI) para administrar el Auto Scaling de DynamoDB. Para obtener más información, consulte [Uso de la AWS CLI para administrar la función Auto Scaling de DynamoDB](AutoScaling.CLI.md). **Topics** + [Antes de comenzar: concesión de permisos a los usuarios para la función Auto Scaling de DynamoDB](#AutoScaling.Permissions) + [Creación de una nueva tabla con la función Auto Scaling habilitada](#AutoScaling.Console.NewTable) + [Habilitación de la función Auto Scaling de DynamoDB en tablas existentes](#AutoScaling.Console.ExistingTable) + [Visualización de las actividades de Auto Scaling en la consola](#AutoScaling.Console.ViewingActivities) + [Modificación o deshabilitación de la configuración de Auto Scaling de DynamoDB](#AutoScaling.Console.Modifying) ## Antes de comenzar: concesión de permisos a los usuarios para la función Auto Scaling de DynamoDB En AWS Identity and Access Management (IAM), la política `DynamoDBFullAccess` administrada por AWS proporciona los permisos necesarios para utilizar la consola de DynamoDB. No obstante, para el escalamiento automático de DynamoDB, los usuarios necesitan permisos adicionales. **importante** Para eliminar una tabla habilitada para el escalado automático se necesitan permisos `application-autoscaling:*`. La política `DynamoDBFullAccess` administrada por AWS incluye estos permisos. Para configurar un usuario para el acceso a la consola de DynamoDB y el escalamiento automático de DynamoDB, cree un rol y agregue la política **AmazonDynamoDBFullAccess** a dicho rol. A continuación, asigne el rol a un usuario. ## Creación de una nueva tabla con la función Auto Scaling habilitada **nota** El escalamiento automático de DynamoDB requiere la presencia de un rol vinculado al servicio (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) que realice acciones de escalamiento automático en su nombre. Este rol se crea automáticamente. Para obtener más información, consulte [Roles vinculados a servicios de Auto Scaling de aplicaciones](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) en la *Guía del usuario de Auto Scaling de aplicaciones*. **Para crear una nueva tabla con la función Auto Scaling habilitada** 1. Abra la consola de DynamoDB en [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/). 1. Seleccione **Create table**. 1. En la página **Crear tabla**, ingrese los detalles de **Nombre de tabla** y clave principal. 1. Si elige **Configuración predeterminada**, el escalado automático se habilita en la nueva tabla. De lo contrario, elija **Personalizar la configuración** y haga lo siguiente para especificar la configuración personalizada de la tabla: 1. Para **Clase de tabla**, mantenga la selección predeterminada de **DynamoDB Standard**. 1. Para la **Configuración de la capacidad de lectura o escritura**, mantenga la selección predeterminada de **Aprovisionada** y, a continuación, haga lo siguiente: 1. Para la **Capacidad de lectura**, asegúrese de que el **Escalado automático** esté configurado en **Activado**. 1. Para la **Capacidad de escritura**, asegúrese de que el **Escalado automático** esté configurado en **Activado**. 1. Para **Capacidad de lectura** y **Capacidad de escritura**, establezca la política de escalado que desee para la tabla y, opcionalmente, para todos los índices secundarios globales de la tabla. + **Unidades de capacidad mínimas**: introduzca el límite inferior del intervalo de escalamiento automático. + **Unidades de capacidad máxima**: introduzca el límite superior del intervalo de escalamiento automático. + **Objetivo de utilización**: introduzca su porcentaje de utilización objetivo para la tabla. **nota** Si crea un índice secundario global para la nueva tabla, la capacidad del índice en el momento de la creación será la misma que la capacidad de la tabla base. Puede cambiar la capacidad del índice en la configuración de la tabla después de crearla. 1. Seleccione **Create table (Creación de tabla)**. Esto crea la tabla con los parámetros de escalado automático especificados. ## Habilitación de la función Auto Scaling de DynamoDB en tablas existentes **nota** El escalamiento automático de DynamoDB requiere la presencia de un rol vinculado al servicio (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) que realice acciones de escalamiento automático en su nombre. Este rol se crea automáticamente. Para obtener más información, consulte [Roles vinculados a servicios para Aplication Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html). **Para habilitar la función Auto Scaling de DynamoDB en una tabla existente** 1. Abra la consola de DynamoDB en [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/). 1. En el panel de navegación del lado izquierdo de la consola, elija **Tablas**. 1. Elija la tabla en la que desee habilitar el escalado automático y, a continuación, haga lo siguiente: 1. Elija la pestaña **Configuración adicional**. 1. En la sección **Capacidad de lectura/escritura**, elija **Editar**. 1. En la sección **Modo de capacidad**, elija **Aprovisionado**. 1. En la sección **Capacidad de tabla**, establezca **Escalado automático** en **Activado** para **Capacidad de lectura**, **Capacidad de escritura** o ambas. Para cada uno de ellos, establezca la política de escalado que desee para la tabla y, opcionalmente, para todos los índices secundarios globales de la tabla. + **Unidades de capacidad mínimas**: introduzca el límite inferior del intervalo de escalamiento automático. + **Unidades de capacidad máxima**: introduzca el límite superior del intervalo de escalamiento automático. + **Objetivo de utilización**: introduzca su porcentaje de utilización objetivo para la tabla. + **Usar la misma configuración de capacidad de lectura/escritura para todos los índices secundarios globales**: elija si los índices secundarios globales deben utilizar la misma política de escalamiento automático que la tabla base. **nota** Para obtener el máximo rendimiento, le recomendamos que habilite la opción **Use the same read/write capacity settings for all global secondary indexes** (Utilizar la misma configuración de capacidad de lectura/escritura para todos los índices secundarios globales). Esta opción permite que la función Auto Scaling de DynamoDB pueda escalar uniformemente todos los índices secundarios globales de la tabla base. Esto incluye los índices secundarios globales existentes y cualquier otro que se creen en esta tabla en el futuro. Con esta opción habilitada, no se puede establecer una política de escalado para un índice secundario global individual. 1. Cuando la configuración sea la que desea, elija **Save (Guardar)**. ## Visualización de las actividades de Auto Scaling en la consola A medida que la aplicación envía tráfico de lectura y escritura a la tabla, la función Auto Scaling de DynamoDB modifica de forma dinámica la configuración de rendimiento de esa tabla. Amazon CloudWatch realiza un seguimiento de la capacidad aprovisionada y consumida, los eventos limitados, la latencia y otras métricas de todas las tablas de DynamoDB e índices secundarios. Para ver estas métricas en la consola de DynamoDB, elija la tabla con la que desee trabajar y seleccione la pestaña **Monitorear**. Para crear una vista personalizable de las métricas de tabla, seleccione **View all in CloudWatch** (Ver todo en CloudWatch). ## Modificación o deshabilitación de la configuración de Auto Scaling de DynamoDB Puede utilizar la Consola de administración de AWS para modificar la configuración de Auto Scaling de DynamoDB. Para ello, vaya a la pestaña **Configuración adicional** de la tabla y elija **Editar** en la sección **Capacidad de lectura/escritura**. Para obtener más información sobre estas opciones, consulte [Habilitación de la función Auto Scaling de DynamoDB en tablas existentes](#AutoScaling.Console.ExistingTable). # Uso de la AWS CLI para administrar la función Auto Scaling de DynamoDB En lugar de utilizar la Consola de administración de AWS, puede utilizar la AWS Command Line Interface (AWS CLI) para administrar la función Auto Scaling de Amazon DynamoDB. En el tutorial de esta sección se muestra cómo instalar y configurar la AWS CLI para administrar la función Auto Scaling de DynamoDB. En este tutorial, aprenderá a hacer lo siguiente: + Creación de una tabla de DynamoDB llamada `TestTable`. Los ajustes de desempeño iniciales son 5 unidades de capacidad de lectura y 5 unidades de capacidad de escritura. + Cree una política Auto Scaling de aplicaciones para `TestTable`. La política está dirigida a mantener una proporción objetivo del 50 % entre la capacidad de escritura consumida y la capacidad de escritura provisionada. El rango de esta métrica está comprendido entre 5 y 10 unidades de capacidad de escritura. (Auto Scaling de aplicaciones no puede ajustar el rendimiento fuera de este rango). + Ejecute un programa en Python para dirigir tráfico de escritura a `TestTable`. Cuando la proporción objetivo supere el 50 % durante un periodo prolongado, el Auto Scaling de aplicaciones se lo notificará a DynamoDB para que ajuste el rendimiento de `TestTable` al alza y, de este modo, mantener el 50 % de utilización de destinos. + Compruebe que DynamoDB haya ajustado correctamente la capacidad de escritura aprovisionada para `TestTable`. **nota** También puede programar el escalado de DynamoDB para que se realice en determinados momentos. Descubra los pasos básicos [aquí](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html). **Topics** + [Antes de empezar](#AutoScaling.CLI.BeforeYouBegin) + [Paso 1: crear una tabla de DynamoDB](#AutoScaling.CLI.CreateTable) + [Paso 2: registrar un objetivo escalable](#AutoScaling.CLI.RegisterScalableTarget) + [Paso 3: crear una política de escalado](#AutoScaling.CLI.CreateScalingPolicy) + [Paso 4: dirigir tráfico de escritura a TestTable](#AutoScaling.CLI.DriveTraffic) + [Paso 5: consultar las acciones de Auto Scaling de aplicaciones](#AutoScaling.CLI.ViewCWAlarms) + [(Opcional) Paso 6: limpiar](#AutoScaling.CLI.CleanUp) ## Antes de empezar Complete las siguientes tareas antes de comenzar el tutorial. ### Instala la AWS CLI Si aún no lo ha hecho, debe instalar y configurar la AWS CLI. Para ello, siga las siguientes instrucciones en la *Guía del usuario de AWS Command Line Interface*: + [Instalación del AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) + [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) ### Instalación de Python Una parte de este tutorial requiere que se ejecute un programa en Python (consulte [Paso 4: dirigir tráfico de escritura a TestTable](#AutoScaling.CLI.DriveTraffic)). Si aún no lo tiene instalado, puede [descargar Python](https://www.python.org/downloads). ## Paso 1: crear una tabla de DynamoDB En este paso, utilice la AWS CLI para crear una `TestTable`. La clave principal consta de `pk` (clave de partición) y `sk` (clave de ordenación). Ambos atributos son de tipo `Number`. Los ajustes de desempeño iniciales son 5 unidades de capacidad de lectura y 5 unidades de capacidad de escritura. 1. Utilice el siguiente comando de la AWS CLI para crear la tabla. ``` 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 comprobar el estado de la tabla, use el comando siguiente. ``` aws dynamodb describe-table \ --table-name TestTable \ --query "Table.[TableName,TableStatus,ProvisionedThroughput]" ``` La tabla está lista para usarla cuando su estado es `ACTIVE`. ## Paso 2: registrar un objetivo escalable Ahora, vamos a registrar la capacidad de escritura de la tabla como objetivo escalable con Auto Scaling de aplicaciones. Esto permite que Auto Scaling de aplicaciones ajuste la capacidad de escritura aprovisionada para *TestTable*, pero solo dentro del rango de entre 5 y 10 unidades de capacidad. **nota** La función Auto Scaling de DynamoDB requiere la presencia de un rol (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) que lleve a cabo las acciones de escalado automático en su nombre. Este rol se crea automáticamente para usted. Para obtener más información, consulte [Roles vinculados a servicios de Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) en la *Guía del usuario de Application Auto Scaling*. 1. Ingrese el siguiente comando para registrar el objetivo escalable. ``` 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 comprobar el registro, utilice el siguiente comando. ``` aws application-autoscaling describe-scalable-targets \ --service-namespace dynamodb \ --resource-id "table/TestTable" ``` **nota** También puede registrar un destino escalable en un índice secundario global. Por ejemplo, para un índice secundario global (“test-index”), el ID de recurso y los argumentos de dimensión escalable se actualizan adecuadamente. ``` 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 ``` ## Paso 3: crear una política de escalado En este paso, se crea una política de escalado para `TestTable`. La política define los detalles según los cuales Auto Scaling de aplicaciones puede ajustar el rendimiento aprovisionado de la tabla y las acciones llevará a cabo para ello. Puede asociar esta política al objetivo escalable definido en el paso anterior (unidades de capacidad de escritura para la tabla `TestTable`). La política contiene los componentes siguientes: + `PredefinedMetricSpecification`: métrica que puede ajustar Auto Scaling de aplicaciones. Para DynamoDB, los siguientes valores son válidos para `PredefinedMetricType`: + `DynamoDBReadCapacityUtilization` + `DynamoDBWriteCapacityUtilization` + `ScaleOutCooldown`: cantidad mínima de tiempo (en segundos) entre cada evento de Auto Scaling de aplicaciones que aumenta el rendimiento aprovisionado. Este parámetro permite que Auto Scaling de aplicaciones aumente de forma continua, pero no drástica, el rendimiento en respuesta a las cargas de trabajo reales. El ajuste predeterminado de `ScaleOutCooldown` es 0. + `ScaleInCooldown`: cantidad mínima de tiempo (en segundos) entre cada evento de Auto Scaling de aplicaciones que reduce el rendimiento aprovisionado. Este parámetro permite que Auto Scaling de aplicaciones disminuya el rendimiento de manera gradual y predecible. El ajuste predeterminado de `ScaleInCooldown` es 0. + `TargetValue`: Auto Scaling de aplicaciones se asegura de que la proporción entre capacidad consumida y capacidad aprovisionada se mantenga en este valor o en un valor próximo. `TargetValue` se define como un porcentaje. **nota** Para entender cómo funciona `TargetValue`, imagine que tiene una tabla con una configuración de rendimiento aprovisionado de 200 unidades de capacidad de escritura. Decide crear una política de escalado para esta tabla, con un valor de `TargetValue` del 70 %. Ahora, supongamos que comienza a dirigir el tráfico de escritura a la tabla, de tal forma que el rendimiento de escritura real es de 150 unidades de capacidad. La proporción entre capacidad consumida y aprovisionada es ahora de (150/200), es decir, del 75 %. Esta proporción supera su objetivo, de modo que Auto Scaling de aplicaciones aumenta la capacidad de escritura aprovisionada a 215 para que la proporción sea de (150/215), es decir, del 69,77 %; de esta forma se mantiene lo más próxima posible al valor de `TargetValue`, pero sin superarlo. Para `TestTable`, configure `TargetValue` hasta el 50 %. Auto Scaling de aplicaciones ajusta el rendimiento aprovisionado de la tabla dentro del rango comprendido entre 5 y 10 unidades de capacidad (consulte [Paso 2: registrar un objetivo escalable](#AutoScaling.CLI.RegisterScalableTarget)), de tal forma que la proporción entre capacidad consumida y provisionada se mantiene en el 50 % o en un valor próximo a este. Los valores de `ScaleOutCooldown` y `ScaleInCooldown` se establecen en 60 segundos. 1. Cree un archivo denominado `scaling-policy.json` con el siguiente contenido. ``` { "PredefinedMetricSpecification": { "PredefinedMetricType": "DynamoDBWriteCapacityUtilization" }, "ScaleOutCooldown": 60, "ScaleInCooldown": 60, "TargetValue": 50.0 } ``` 1. Utilice el siguiente comando de la AWS CLI para crear la 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. En el resultado, observe que Auto Scaling de aplicaciones ha creado dos alarmas de Amazon CloudWatch, una para cada límite (superior e inferior) del rango de escalado objetivo. 1. Utilice el comando de AWS CLI siguiente para ver más detalles sobre la política de escalado. ``` aws application-autoscaling describe-scaling-policies \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --policy-name "MyScalingPolicy" ``` 1. En el resultado, compruebe que los ajustes de la política coincidan con las especificaciones de [Paso 2: registrar un objetivo escalable](#AutoScaling.CLI.RegisterScalableTarget) y [Paso 3: crear una política de escalado](#AutoScaling.CLI.CreateScalingPolicy). ## Paso 4: dirigir tráfico de escritura a TestTable Ahora puede probar la política de escalado escribiendo datos en . `TestTable`. Para ello, deberá ejecutar un programa en Python. 1. Cree un archivo denominado `bulk-load-test-table.py` con el siguiente contenido. ``` 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 ejecutar el programa, introduzca el siguiente comando. `python bulk-load-test-table.py` La capacidad de escritura provisionada de `TestTable` es muy baja (5 unidades de capacidad de escritura), por lo que el programa se ahoga en ocasiones a causa de la limitación controlada de escritura. Este es el comportamiento esperado. Permita que el programa continúe ejecutándose mientras avanza al paso siguiente. ## Paso 5: consultar las acciones de Auto Scaling de aplicaciones En este paso, consultaremos las acciones de Auto Scaling de aplicaciones que se han iniciado en su nombre. Además, comprobaremos que Auto Scaling de aplicaciones ha actualizado la capacidad de escritura provisionada para `TestTable`. 1. Ingrese el siguiente comando para ver las acciones de Auto Scaling de aplicaciones. ``` aws application-autoscaling describe-scaling-activities \ --service-namespace dynamodb ``` Vuelva a ejecutar este comando cada cierto tiempo mientras el programa en Python siga en ejecución. (Se tardarán varios minutos hasta que se invoque la política de escalado). En algún momento, debería aparecer el resultado siguiente. ``` ... { "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" }, ... ``` Esto indica que el Auto Scaling de aplicaciones ha emitido una solicitud `UpdateTable` a DynamoDB. 1. Ingrese el siguiente comando para comprobar que DynamoDB ha aumentado la capacidad de escritura de la tabla. ``` aws dynamodb describe-table \ --table-name TestTable \ --query "Table.[TableName,TableStatus,ProvisionedThroughput]" ``` `WriteCapacityUnits` debería haberse escalado de `5` a `10`. ## (Opcional) Paso 6: limpiar En este tutorial, ha creado varios recursos. Puede eliminar estos recursos cuando ya los necesite. 1. Elimine la política de escalado para `TestTable`. ``` aws application-autoscaling delete-scaling-policy \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" \ --policy-name "MyScalingPolicy" ``` 1. Anule el registro del objetivo escalable. ``` aws application-autoscaling deregister-scalable-target \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" ``` 1. Elimine la tabla `TestTable`. ``` aws dynamodb delete-table --table-name TestTable ``` # Uso del AWS SDK para configurar escalado automático en tablas de Amazon DynamoDB Además de utilizar la Consola de administración de AWS y la AWS Command Line Interface (AWS CLI), puede escribir aplicaciones que interaccionen con el escalado automático de Amazon DynamoDB. Esta sección contiene dos programas de Java que puede utilizar para probar esta funcionalidad: + `EnableDynamoDBAutoscaling.java` + `DisableDynamoDBAutoscaling.java` ## Habilitación de Auto Scaling de aplicaciones para una tabla En el siguiente programa se muestra un ejemplo de cómo configurar una política de escalado automático para una tabla de DynamoDB (`TestTable`). Funciona de la siguiente manera: + El programa registra las unidades de capacidad de escritura como objetivo escalable de `TestTable`. El rango de esta métrica está comprendido entre 5 y 10 unidades de capacidad de escritura. + Después de crear el objetivo escalable, el programa crea una configuración de seguimiento del objetivo. La política está dirigida a mantener una proporción objetivo del 50 % entre la capacidad de escritura consumida y la capacidad de escritura provisionada. + Después, el programa crea la política de escalado basada en la configuración de seguimiento del objetivo. **nota** Cuando se elimina manualmente una tabla o réplica de tabla global, no se eliminan automáticamente los destinos escalables asociados, las políticas de escalado o las alarmas de 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 ] El programa requiere que se suministre el nombre de recurso de Amazon (ARN) de un rol vinculado a un servicio de Auto Scaling de aplicaciones válido. (Por ejemplo: `arn:aws:iam::122517410325:role/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`.) En el siguiente programa, sustituya `SERVICE_ROLE_ARN_GOES_HERE` por el 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()); } } } ``` ------ ## Desactivación de Auto Scaling de aplicaciones para una tabla En el siguiente programa se invierte el proceso anterior. Se elimina la política de escalado automático y, a continuación, se anula el registro del objetivo escalable. ------ #### [ 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()); } } } ``` ------