Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Gestione automatica della capacità effettiva di trasmissione con il dimensionamento automatico di DynamoDB Molti carichi di lavoro dei database sono per natura ciclici o sono difficili da prevedere in anticipo. Ad esempio, considera un'app di social network in cui la maggior parte degli utenti sono attivi durante le ore diurne. Il database deve essere in grado di gestire l'attività diurna e ciò non è necessario per gli stessi livelli di throughput durante la notte. Un altro esempio potrebbe essere una nuova app di gioco per dispositivi mobili che si sta improvvisamente diffondendo in modo rapido. Se il gioco si diffonde troppo, potrebbe superare le risorse di database disponibili, con un conseguente rallentamento delle prestazioni e diversi clienti insoddisfatti. Questi tipi di carichi di lavoro richiedono spesso l'intervento manuale per aumentare o diminuire le risorse di database in risposta alla variazione dei livelli di utilizzo. La scalabilità automatica di Amazon DynamoDB utilizza il servizio Application AWS Auto Scaling per regolare dinamicamente la capacità di throughput assegnata per tuo conto, in risposta ai modelli di traffico effettivi. In tal modo una tabella o un indice secondario globale (GSI) può aumentare la capacità di lettura e scrittura allocata per gestire improvvisi aumenti di traffico senza limitazione (della larghezza di banda della rete). Quando il carico di lavoro diminuisce, Application Auto Scaling riduce la velocità effettiva in modo da non dover pagare per la capacità assegnata inutilizzata. **Nota** Se si utilizza il Console di gestione AWS per creare una tabella o un indice secondario globale, la scalabilità automatica di DynamoDB è abilitata per impostazione predefinita. Puoi modificare le tue impostazioni di scalabilità automatica in qualsiasi momento. Per ulteriori informazioni, consulta [Utilizzo della scalabilità Console di gestione AWS automatica con DynamoDB](AutoScaling.Console.md). Quando si elimina una tabella o una replica globale di una tabella, tutti gli obiettivi scalabili, le politiche di ridimensionamento o gli CloudWatch allarmi associati non vengono eliminati automaticamente con essa. Con Application Auto Scaling, è possibile creare una *policy di dimensionamento* per una tabella o un indice secondario globale. La policy di dimensionamento specifica se desideri dimensionare la capacità di lettura o di scrittura (o e entrambe) e indica le impostazioni delle unità di capacità minime e massime assegnate per la tabella o l'indice. La policy di dimensionamento contiene anche un *utilizzo di destinazione*: la percentuale di velocità effettiva assegnata consumata in un dato momento. Application Auto Scaling utilizza un *monitoraggio degli obiettivi* per regolare la velocità effettiva assegnata della tabella (o dell'indice) in alto o in basso, in risposta a carichi di lavoro effettivi in modo che l'utilizzo effettivo della capacità rimanga pari o vicino all'utilizzo di destinazione. DynamoDB fornisce il throughput allocato utilizzato per periodi di un minuto. La scalabilità automatica si attiva quando la capacità consumata supera l'utilizzo previsto configurato per due minuti consecutivi. CloudWatch gli allarmi potrebbero avere un breve ritardo, fino a qualche minuto, prima di attivare il ridimensionamento automatico. Questo ritardo garantisce una valutazione metrica accurata CloudWatch . Se i picchi di throughput utilizzato distano più di un minuto, il dimensionamento automatico potrebbe non attivarsi. Analogamente, un evento di riduzione verticale può avvenire quando 15 punti dati consecutivi sono inferiori all’utilizzo di destinazione. In entrambi i casi, dopo i trigger di auto scaling, viene richiamata l'[UpdateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html)API. Sono quindi necessari alcuni minuti per aggiornare la capacità allocata per la tabella o l’indice. Durante questo periodo, tutte le richieste che superano la capacità allocata precedente delle tabelle verranno sottoposte a limitazione (della larghezza di banda della rete). **Importante** Non è possibile modificare il numero di punti dati da violare per attivare l’allarme sottostante (anche se il numero attuale potrebbe cambiare in futuro). Puoi impostare i valori dell'utilizzo di destinazione del dimensionamento automatico tra il 20 e il 90 percento per la capacità in lettura e scrittura. **Nota** Oltre alle tabelle, la scalabilità automatica di DynamoDB supporta anche gli indici secondari globali. Ogni indice secondario globale dispone della propria capacità di throughput assegnata, separata da quella della relativa tabella di base. Quando si crea una policy di dimensionamento per un indice secondario globale, Application Auto Scaling regola le impostazioni di velocità effettiva assegnata per l'indice per assicurare che il suo utilizzo effettivo rimanga uguale o prossimo alle proporzioni di utilizzo desiderate. ## Funzionamento del dimensionamento automatico di DynamoDB **Nota** Per iniziare a utilizzare rapidamente la scalabilità automatica di DynamoDB, consulta [Utilizzo della scalabilità Console di gestione AWS automatica con DynamoDB](AutoScaling.Console.md). Il seguente diagramma fornisce una panoramica dettagliata del modo in cui la scalabilità automatica di DynamoDB gestisce la capacità di throughput per una tabella: ![\[Il dimensionamento automatico di DynamoDB regola la capacità di throughput di una tabella per soddisfare la domanda.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/auto-scaling.png) Le fasi seguenti sintetizzano il processo di scalabilità automatica come illustrato nel diagramma precedente: 1. È possibile creare una policy di Application Auto Scaling per la tabella DynamoDB. 1. DynamoDB pubblica i parametri della capacità consumata su Amazon. CloudWatch 1. Se la capacità consumata della tabella supera l'utilizzo previsto (o scende al di sotto del target) per un periodo di tempo specifico, Amazon CloudWatch attiva un allarme. È possibile visualizzare l'allarme sulla console e ricevere notifiche tramite Amazon Simple Notification Service (Amazon SNS). 1. L' CloudWatch allarme richiama Application Auto Scaling per valutare la politica di scalabilità. 1. Application Auto Scaling invia una richiesta `UpdateTable` per regolare la velocità effettiva assegnata della tabella. 1. DynamoDB elabora la richiesta `UpdateTable`, aumentando (o diminuendo) in modo dinamico la capacità di throughput assegnata della tabella in modo che si avvicini all'utilizzo di destinazione. Per comprendere come funziona la scalabilità automatica di DynamoDB, si supponga di avere una tabella denominata `ProductCatalog`. La tabella riceve carichi non frequenti di dati in blocco, perciò non esegue molta attività di scrittura. Tuttavia, ciò comporta un alto livello di attività di lettura che varia nel tempo. Monitorando i CloudWatch parametri di Amazon per`ProductCatalog`, stabilisci che la tabella richiede 1.200 unità di capacità di lettura (per evitare che DynamoDB limiti le richieste di lettura quando l'attività è al massimo). Inoltre, stabilisci che `ProductCatalog` richieda minimo 150 unità di capacità in lettura, quando il traffico di lettura è al livello minimo. Per ulteriori informazioni sulla limitazione (della larghezza di banda della rete), consulta [Risoluzione dei problemi di limitazione (della larghezza di banda della rete) in Amazon DynamoDB](TroubleshootingThrottling.md). All'interno dell'intervallo compreso tra 150 e 1.200 unità di capacità in lettura, decidi che una percentuale di utilizzo di destinazione del 70% sia adatta per la tabella `ProductCatalog`. L'*utilizzo di destinazione* viene espresso come proporzione tra le unità di capacità utilizzate e le unità di capacità assegnata, in percentuale. Application Auto Scaling utilizza il suo algoritmo di monitoraggio degli obiettivi per garantire che la capacità di lettura assegnata di `ProductCatalog` sia regolata come richiesto in modo che l'utilizzo rimanga più o meno al 70%. **Nota** La scalabilità automatica di DynamoDB modifica le impostazioni della velocità di trasmissione effettiva assegnata solo quando il carico di lavoro effettivo rimane elevato (o basso) per un periodo continuativo di diversi minuti. L'algoritmo di monitoraggio degli obiettivi di Application Auto Scaling cerca di tenere l'utilizzo della destinazione pari o vicino al valore scelto a lungo termine. I picchi di attività improvvisi e di breve durata sono soddisfatti dalla capacità di ottimizzazione integrata della tabella. Per ulteriori informazioni, consulta [Capacità di ottimizzazione](burst-adaptive-capacity.md#burst-capacity). Per abilitare la scalabilità automatica di DynamoDB per la tabella `ProductCatalog`, viene creata una policy di dimensionamento. La policy specifica quanto segue: + La tabella o l'indice secondario globale che desideri gestire + Il tipo di capacità da gestire (capacità di lettura o capacità di scrittura) + I limiti superiore e inferiore per le impostazioni del throughput assegnato + Utilizzo di destinazione Quando crei una politica di scalabilità, Application Auto Scaling crea un paio di allarmi CloudWatch Amazon per tuo conto. Ogni coppia rappresenta i limiti superiore e inferiore per le impostazioni della velocità di trasmissione effettiva assegnata. Questi CloudWatch allarmi vengono attivati quando l'utilizzo effettivo della tabella si discosta dall'utilizzo previsto per un periodo di tempo prolungato. Quando viene attivato uno degli CloudWatch allarmi, Amazon SNS ti invia una notifica (se l'hai abilitata). L' CloudWatch allarme richiama quindi Application Auto Scaling, che a sua volta notifica a DynamoDB di modificare la capacità assegnata alla tabella verso l'alto o verso il basso, a seconda `ProductCatalog` dei casi. Durante un evento di scalabilità, viene addebitato per elemento di configurazione registrato. AWS Config Quando si verifica un evento di ridimensionamento, vengono creati quattro CloudWatch allarmi per ogni evento di auto-scaling di lettura e scrittura: alarms: e ProvisionedCapacity alarms:,. ProvisionedCapacityLow ProvisionedCapacityHigh ConsumedCapacity AlarmHigh AlarmLow Ciò dà luogo a un totale di otto allarmi. Pertanto, AWS Config registra otto elementi di configurazione per ogni evento di scalabilità. **Nota** È possibile anche pianificare il dimensionamento di DynamoDB in modo che avvenga in determinati momenti. La procedura di base è disponibile [qui](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html). ## Note per l’utilizzo Prima di iniziare a utilizzare la scalabilità automatica di DynamoDB è necessario tenere presente quanto riportato di seguito: + La scalabilità automatica di DynamoDB può aumentare la capacità di lettura o di scrittura in base alle necessità e secondo la policy di scalabilità automatica. Tutti le quote di DynamoDB restano in vigore, come descritto in [Quote in Amazon DynamoDB](ServiceQuotas.md). + La scalabilità automatica di DynamoDB non impedisce di modificare manualmente le impostazioni di velocità effettiva assegnata. Queste regolazioni manuali non influiscono sugli CloudWatch allarmi esistenti correlati alla scalabilità automatica di DynamoDB. + Se si abilita la scalabilità automatica di DynamoDB per una tabella che ha uno o più indici secondari globali, consigliamo di applicare la scalabilità automatica in maniera uniforme anche a quegli indici. Ciò contribuirà a garantire prestazioni migliori per la scrittura e la lettura delle tabelle e a evitare la limitazione della larghezza di banda della rete. È possibile abilitare la scalabilità automatica selezionando **Apply same settings to global secondary indexes** (Applica le stesse impostazioni agli indici secondari globali) nella Console di gestione AWS. Per ulteriori informazioni, consulta [Abilitazione del dimensionamento automatico di DynamoDB su tabelle esistenti](AutoScaling.Console.md#AutoScaling.Console.ExistingTable). + Quando si elimina una tabella o una replica globale di una tabella, tutti gli obiettivi scalabili, le policy di ridimensionamento o gli allarmi associati non vengono eliminati automaticamente con essa. CloudWatch + Quando si crea un GSI per una tabella esistente, il dimensionamento automatico non è abilitato per il GSI. Dovrai gestire manualmente la capacità mentre il GSI è in fase di costruzione. Una volta completato il backfill sul GSI e raggiunto lo stato attivo, la scalabilità automatica funzionerà normalmente. # Utilizzo della scalabilità Console di gestione AWS automatica con DynamoDB Quando usi il Console di gestione AWS per creare una nuova tabella, la scalabilità automatica di Amazon DynamoDB è abilitata per quella tabella per impostazione predefinita. È possibile utilizzare la console anche per abilitare la scalabilità automatica per le tabelle esistenti, modificare le impostazioni di scalabilità automatica o disabilitare la scalabilità automatica. **Nota** Per funzionalità più avanzate come l'impostazione dei tempi di cooldown scale-in e scale-out, usa il AWS Command Line Interface () per AWS CLI gestire la scalabilità automatica di DynamoDB. Per ulteriori informazioni, consulta [Utilizzo di AWS CLI per gestire la scalabilità automatica di DynamoDB](AutoScaling.CLI.md). **Topics** + [Prima di iniziare: concessione delle autorizzazioni utente per il dimensionamento automatico di DynamoDB](#AutoScaling.Permissions) + [Creazione di una nuova tabella con il dimensionamento automatico abilitato](#AutoScaling.Console.NewTable) + [Abilitazione del dimensionamento automatico di DynamoDB su tabelle esistenti](#AutoScaling.Console.ExistingTable) + [Visualizzazione delle attività di dimensionamento automatico sulla console](#AutoScaling.Console.ViewingActivities) + [Modifica o disabilitazione delle impostazioni di dimensionamento automatico di DynamoDB](#AutoScaling.Console.Modifying) ## Prima di iniziare: concessione delle autorizzazioni utente per il dimensionamento automatico di DynamoDB In AWS Identity and Access Management (IAM), la policy AWS gestita `DynamoDBFullAccess` fornisce le autorizzazioni necessarie per l'utilizzo della console DynamoDB. Tuttavia, per dimensionamento automatico di DynamoDB, gli utenti IAM richiedono autorizzazioni aggiuntive. **Importante** Le autorizzazioni sono necessarie per eliminare una tabella abilitata per il dimensionamento automatico. La policy AWS gestita `DynamoDBFullAccess` include tali autorizzazioni. **Per configurare un utente per l'accesso alla console DynamoDB e la scalabilità automatica di DynamoDB, crea un ruolo e aggiungi la politica di accesso a quel ruolo. AmazonDynamo DBFull** Quindi assegna il ruolo a un utente. ## Creazione di una nuova tabella con il dimensionamento automatico abilitato **Nota** Il dimensionamento automatico di DynamoDB richiede la presenza di un ruolo collegato al servizio (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) che esegue operazioni di dimensionamento automatico per conto dell’utente. Questo ruolo viene creato automaticamente per te. Per ulteriori informazioni, consulta [Ruoli collegati ai servizi per Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) nella *Guida per l’utente di Application Auto Scaling*. **Come creare una nuova tabella con la scalabilità automatica abilitata** 1. Apri la console DynamoDB all'indirizzo. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Scegliere **Create table (Crea tabella)**. 1. Nella pagina **Crea tabella**, inserisci un **Nome tabella** e i dettagli della chiave primaria. 1. Selezionando **Impostazioni predefinite**, il dimensionamento automatico sarà abilitato nella nuova tabella. Altrimenti, seleziona **Personalizza impostazioni** ed effettua le seguenti operazioni per specificare le impostazioni personalizzate per la tabella: 1. Per **Classe tabella**, mantieni la selezione predefinita di **DynamoDB Standard**. 1. Per **Impostazioni di capacità in scrittura/lettura**, mantieni la selezione predefinita di **Provisioning effettuato**, quindi procedi come segue: 1. Per la **Capacità in lettura**, assicurati che **Auto Scaling** sia impostato su **Attivo**. 1. Per la **Capacità in scrittura**, assicurati che **Auto Scaling** sia impostato su **Attivo**. 1. Per **Capacità in lettura** e **Capacità in scrittura**, imposta la policy di dimensionamento desiderata per la tabella e, facoltativamente, per tutti gli indici secondari globali della tabella. + **Unità di capacità minima**: inserisci il limite inferiore dell'intervallo di dimensionamento automatico. + **Unità di capacità massima**: inserisci il limite superiore dell'intervallo di dimensionamento automatico. + **Utilizzo destinazione**: inserisci la percentuale di utilizzo destinazione per la tabella. **Nota** Se crei un indice secondario globale per la nuova tabella, la capacità dell'indice al momento della creazione sarà uguale alla capacità di base della tabella. Puoi modificare la capacità dell'indice nelle impostazioni della tabella dopo aver creato la tabella. 1. Scegliere **Create table (Crea tabella)**. Questa azione crea la tabella con i parametri di dimensionamento automatico specificati. ## Abilitazione del dimensionamento automatico di DynamoDB su tabelle esistenti **Nota** Il dimensionamento automatico di DynamoDB richiede la presenza di un ruolo collegato al servizio (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) che esegue operazioni di dimensionamento automatico per conto dell’utente. Questo ruolo viene creato automaticamente per te. Per ulteriori informazioni, consulta [Ruoli collegati ai servizi per Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html). **Come abilitare la scalabilità automatica DynamoDB per una tabella esistente** 1. Apri la console DynamoDB all'indirizzo. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Nel riquadro di navigazione sul lato sinistro della console scegli **Tables (Tabelle)**. 1. Seleziona la tabella in cui desideri abilitare il dimensionamento automatico, quindi segui questa procedura: 1. Vai alla scheda **Impostazioni aggiuntive**. 1. Nella sezione **Capacità di lettura/scrittura**, scegli **Modifica**. 1. Nella sezione **Modalità di capacità**, scegli **Assegnata**. 1. Nella sezione **Table capacity (Capacità tabella)**, imposta **Auto Scaling (Scalabilità automatica)** su **On (Attiva)** per **Read capacity (Capacità di lettura)**, **Write capacity (Capacità di scrittura)** o entrambe. Per ognuna di queste, imposta la policy di dimensionamento desiderata per la tabella e, facoltativamente, tutti gli indici secondari globali della tabella. + **Unità di capacità minima**: inserisci il limite inferiore dell'intervallo di dimensionamento automatico. + **Unità di capacità massima**: inserisci il limite superiore dell'intervallo di dimensionamento automatico. + **Utilizzo destinazione**: inserisci la percentuale di utilizzo destinazione per la tabella. + **Utilizza le stesse impostazioni di read/write capacità per tutti gli indici secondari globali**: scegli se gli indici secondari globali devono utilizzare la stessa politica di scalabilità automatica della tabella di base. **Nota** Per prestazioni ottimali, si consiglia di abilitare l'opzione **Usa le stesse impostazioni di read/write capacità per tutti gli** indici secondari globali. Questa opzione consente alla scalabilità automatica di DynamoDB di dimensionare uniformemente tutti gli indici secondari globali nella tabella di base. Sono inclusi gli indici secondari globali esistenti e tutti gli altri che verranno creati per questa tabella in futuro. Se questa opzione è abilitata, non è possibile impostare una policy di dimensionamento su un singolo indice secondario globale. 1. Dopo aver selezionato le impostazioni desiderate, scegli **Save (Salva)**. ## Visualizzazione delle attività di dimensionamento automatico sulla console Man mano che l'applicazione guida il traffico di lettura e scrittura nella tabella, la scalabilità automatica di DynamoDB modifica dinamicamente le impostazioni della velocità effettiva della tabella. Amazon CloudWatch tiene traccia della capacità fornita e consumata, degli eventi limitati, della latenza e di altri parametri per tutte le tabelle e gli indici secondari DynamoDB. Per visualizzare queste metriche nella console DynamoDB, scegli la tabella che desideri utilizzare e seleziona la scheda **Monitora**. **Per creare una visualizzazione personalizzabile delle metriche della tabella, seleziona Visualizza tutto in. CloudWatch** ## Modifica o disabilitazione delle impostazioni di dimensionamento automatico di DynamoDB È possibile utilizzare il Console di gestione AWS per modificare le impostazioni di autoscaling di DynamoDB. Per eseguire questa operazione, vai alla scheda **Impostazioni aggiuntive** della tua tabella e seleziona **Modifica** nella sezione **Capacità di lettura/scrittura**. Per ulteriori informazioni su queste impostazioni, consultare [Abilitazione del dimensionamento automatico di DynamoDB su tabelle esistenti](#AutoScaling.Console.ExistingTable). # Utilizzo di AWS CLI per gestire la scalabilità automatica di DynamoDB Invece di usare il Console di gestione AWS, puoi usare il AWS Command Line Interface (AWS CLI) per gestire la scalabilità automatica di Amazon DynamoDB. Nel tutorial in questa sezione viene illustrato come installare e configurare la AWS CLI per la gestione della scalabilità automatica di DynamoDB. In questo tutorial, esegui quanto indicato di seguito: + Crea una tabella DynamoDB denominata `TestTable`. Le impostazioni di velocità effettiva iniziali sono 5 unità di capacità di lettura e 5 unità di capacità di scrittura. + Crea una policy di Application Auto Scaling per `TestTable`. La policy cerca di mantenere un rapporto obiettivo del 50% tra capacità di scrittura utilizzata e capacità di scrittura assegnata. L'intervallo per questo parametro è compreso tra 5 e 10 unità di capacità di scrittura. (Application Auto Scaling non può regolare la velocità effettiva oltre questo intervallo). + Eseguire un programma Python per indirizzare il traffico di scrittura su `TestTable`. Quando il rapporto di destinazione supera il 50% per un periodo di tempo prolungato, Application Auto Scaling richiede a DynamoDB di regolare la velocità effettiva di `TestTable` verso l'alto in modo da mantenere l'utilizzo della destinazione al 50%. + Verificare che DynamoDB abbia regolato correttamente la capacità di scrittura assegnata per `TestTable`. **Nota** È possibile anche pianificare il dimensionamento di DynamoDB in modo che avvenga in determinati momenti. La procedura di base è disponibile [qui](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html). **Topics** + [Prima di iniziare](#AutoScaling.CLI.BeforeYouBegin) + [Fase 1: creazione di una tabella DynamoDB](#AutoScaling.CLI.CreateTable) + [Fase 2: registrazione di una destinazione scalabile](#AutoScaling.CLI.RegisterScalableTarget) + [Fase 3: creazione di una policy di dimensionamento](#AutoScaling.CLI.CreateScalingPolicy) + [Passaggio 4: Indirizza il traffico di scrittura verso TestTable](#AutoScaling.CLI.DriveTraffic) + [Fase 5: visualizzazione delle operazioni di Application Auto Scaling](#AutoScaling.CLI.ViewCWAlarms) + [(Opzionale) Fase 6: pulizia](#AutoScaling.CLI.CleanUp) ## Prima di iniziare Prima di iniziare il tutorial, completare le attività seguenti: ### Installa AWS CLI Se non l'hai ancora fatto, installa e configura AWS CLI. A questo scopo, seguire le istruzioni fornite nella *Guida per l'utente di AWS Command Line Interface *: + [Installazione dell' AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) + [Configurazione della AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) ### Installazione di Python Parte di questo tutorial richiede l'esecuzione di un programma Python (vedere [Passaggio 4: Indirizza il traffico di scrittura verso TestTable](#AutoScaling.CLI.DriveTraffic)). Se non è già installato, [scaricare Python](https://www.python.org/downloads). ## Fase 1: creazione di una tabella DynamoDB In questo passaggio, si utilizza AWS CLI per creare`TestTable`. La chiave primaria è costituita da `pk` (chiave di partizione) e da `sk` (chiave di ordinamento). Entrambi questi attributi sono di tipo `Number`. Le impostazioni di velocità effettiva iniziali sono 5 unità di capacità di lettura e 5 unità di capacità di scrittura. 1. Utilizzate il seguente AWS CLI comando per creare la tabella. ``` 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. Per verificare lo stato della tabella, utilizza il comando seguente. ``` aws dynamodb describe-table \ --table-name TestTable \ --query "Table.[TableName,TableStatus,ProvisionedThroughput]" ``` La tabella è pronta per l'uso quando lo stato diventa `ACTIVE`. ## Fase 2: registrazione di una destinazione scalabile Successivamente si registra la capacità di scrittura della tabella come destinazione scalabile con Application Auto Scaling. Ciò consente ad Application Auto Scaling di regolare la capacità di scrittura assegnata per *TestTable*, ma solo entro un intervallo di 5-10 unità di capacità. **Nota** La scalabilità automatica di DynamoDB richiede la presenza di un ruolo collegato al servizio (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) che esegue operazioni di scalabilità automatica per conto tuo. Questo ruolo viene creato automaticamente per te. Per ulteriori informazioni, consulta [Ruoli collegati ai servizi per Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) nella *Guida per l’utente di Application Auto Scaling*. 1. Utilizza il comando seguente per registrare la destinazione scalabile. ``` 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. Utilizza il comando seguente per verificare la registrazione. ``` aws application-autoscaling describe-scalable-targets \ --service-namespace dynamodb \ --resource-id "table/TestTable" ``` **Nota** È inoltre possibile registrare una destinazione scalabile rispetto a un indice secondario globale. Ad esempio, per un indice secondario globale ("test-index"), l'ID risorsa e gli argomenti della dimensione scalabile vengono aggiornati di conseguenza. ``` 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 ``` ## Fase 3: creazione di una policy di dimensionamento In questa fase, viene creata una policy di dimensionamento per `TestTable`. La policy definisce i dettagli in base ai quali Application Auto Scaling può regolare la velocità effettiva assegnata della tabella e le operazioni da intraprendere quando lo fa. Questa policy viene associata alla destinazione scalabile definita nel passaggio precedente (unità di capacità di scrittura per la tabella `TestTable`). La policy contiene i seguenti elementi: + `PredefinedMetricSpecification`: il parametro che può essere regolato da Application Auto Scaling. Per DynamoDB, i seguenti valori sono valori validi per`PredefinedMetricType`: + `DynamoDBReadCapacityUtilization` + `DynamoDBWriteCapacityUtilization` + `ScaleOutCooldown`: la quantità minima di tempo (espressa in secondi) tra ogni evento Application Auto Scaling che aumenta la velocità effettiva assegnata. Questo parametro consente ad Application Auto Scaling di aumentare continuamente, ma non in modo aggressivo, la velocità effettiva in risposta ai carichi di lavoro reali. L'impostazione predefinita per `ScaleOutCooldown` è 0. + `ScaleInCooldown`: la quantità minima di tempo (espressa in secondi) tra ogni evento Application Auto Scaling che diminuisce la velocità effettiva assegnata. Questo parametro consente ad Application Auto Scaling di ridurre la velocità effettiva in maniera graduale e prevedibile. L'impostazione predefinita per `ScaleInCooldown` è 0. + `TargetValue`: Application Auto Scaling assicura che il rapporto tra la capacità utilizzata e la capacità assegnata rimanga pari o vicino a questo valore. `TargetValue` viene definito in percentuale. **Nota** Per capire meglio come funziona `TargetValue`, supponiamo di avere una tabella con un'impostazione di velocità effettiva assegnata pari a 200 unità di capacità in scrittura. Si decide di creare una policy di dimensionamento per questa tabella, con un `TargetValue` del 70%. Si supponga ora di iniziare a guidare il traffico di scrittura verso la tabella in modo che la velocità effettiva di scrittura sia di 150 unità di capacità. Il consumed-to-provisioned rapporto è ora (150/ 200), ossia il 75 percento. Questo rapporto supera l'obiettivo, pertanto Application Auto Scaling aumenta la capacità di scrittura assegnata a 215 in modo che il rapporto sia (150/215) o 69,77%, il più vicino possibile a `TargetValue` ma senza superarlo. Per `TestTable`, `TargetValue` si imposta al 50%. Application Auto Scaling regola il throughput assegnato dalla tabella entro un intervallo di 5-10 unità di capacità (vedi[Fase 2: registrazione di una destinazione scalabile](#AutoScaling.CLI.RegisterScalableTarget)) in modo che il consumed-to-provisioned rapporto rimanga pari o vicino al 50 percento. I valori di `ScaleOutCooldown` e `ScaleInCooldown` vengono impostati su 60 secondi. 1. Crea un file denominato `scaling-policy.json` con i seguenti contenuti. ``` { "PredefinedMetricSpecification": { "PredefinedMetricType": "DynamoDBWriteCapacityUtilization" }, "ScaleOutCooldown": 60, "ScaleInCooldown": 60, "TargetValue": 50.0 } ``` 1. Utilizzare il comando seguente per creare la politica AWS CLI . ``` aws application-autoscaling put-scaling-policy \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" \ --policy-name "MyScalingPolicy" \ --policy-type "TargetTrackingScaling" \ --target-tracking-scaling-policy-configuration file://scaling-policy.json ``` 1. Nell'output, tieni presente che Application Auto Scaling ha creato due CloudWatch allarmi Amazon, uno per il limite superiore e inferiore dell'intervallo target di scalabilità. 1. Usa il seguente AWS CLI comando per visualizzare maggiori dettagli sulla politica di scalabilità. ``` aws application-autoscaling describe-scaling-policies \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --policy-name "MyScalingPolicy" ``` 1. Nell'output, verificare che le impostazioni delle policy corrispondano alle specifiche da [Fase 2: registrazione di una destinazione scalabile](#AutoScaling.CLI.RegisterScalableTarget) e [Fase 3: creazione di una policy di dimensionamento](#AutoScaling.CLI.CreateScalingPolicy). ## Passaggio 4: Indirizza il traffico di scrittura verso TestTable Ora è possibile testare la policy di dimensionamento scrivendo i dati in `TestTable`. Per fare ciò, viene eseguito un programma Python. 1. Crea un file denominato `bulk-load-test-table.py` con i seguenti contenuti. ``` 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. Per eseguire il programma, immettere il comando seguente. `python bulk-load-test-table.py` La capacità di scrittura assegnata per `TestTable` è molto bassa (5 unità di capacità di scrittura), quindi il programma si blocca occasionalmente a causa della limitazione della scrittura. Questo è il comportamento previsto. Lasciare che il programma continui a funzionare mentre si passa alla fase successiva. ## Fase 5: visualizzazione delle operazioni di Application Auto Scaling In questa fase vengono visualizzate le operazioni di Application Auto Scaling che vengono avviate per conto tuo. Viene inoltre verificato che Application Auto Scaling abbia aggiornato la capacità di scrittura assegnata per `TestTable`. 1. Immettere il comando seguente per visualizzare le operazioni di Application Auto Scaling. ``` aws application-autoscaling describe-scaling-activities \ --service-namespace dynamodb ``` Eseguire di nuovo questo comando occasionalmente, mentre il programma Python è in esecuzione. Occorrono diversi minuti prima che la policy di dimensionamento venga richiamata. Dovrebbe essere visualizzato l'output riportato di seguito. ``` ... { "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" }, ... ``` Ciò indica che Application Auto Scaling ha emesso una richiesta `UpdateTable` a DynamoDB. 1. Immettere il comando seguente per verificare che DynamoDB ha aumentato la capacità di scrittura della tabella. ``` aws dynamodb describe-table \ --table-name TestTable \ --query "Table.[TableName,TableStatus,ProvisionedThroughput]" ``` `WriteCapacityUnits` dovrebbe essersi dimensionato da `5` a `10`. ## (Opzionale) Fase 6: pulizia In questo tutorial sono state create diverse risorse. È possibile eliminare queste risorse se non sono più necessarie. 1. Eliminare la policy di dimensionamento per `TestTable`. ``` aws application-autoscaling delete-scaling-policy \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" \ --policy-name "MyScalingPolicy" ``` 1. Annullare la registrazione di una destinazione scalabile. ``` aws application-autoscaling deregister-scalable-target \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" ``` 1. Eliminare la tabella `TestTable`. ``` aws dynamodb delete-table --table-name TestTable ``` # Utilizzo dell' AWS SDK per configurare la scalabilità automatica sulle tabelle Amazon DynamoDB Oltre a utilizzare Console di gestione AWS and the AWS Command Line Interface (AWS CLI), puoi scrivere applicazioni che interagiscono con la scalabilità automatica di Amazon DynamoDB. Questa sezione contiene due programmi Java che puoi utilizzare per verificare questa funzionalità: + `EnableDynamoDBAutoscaling.java` + `DisableDynamoDBAutoscaling.java` ## Abilitazione di Application Auto Scaling per una tabella Nel programma seguente viene riportato un esempio di configurazione di una policy di scalabilità automatica per una tabella DynamoDB (`TestTable`). Si procede nel seguente modo. + Il programma registra unità di capacità in scrittura come un obiettivo scalabile per `TestTable`. L'intervallo per questo parametro è compreso tra 5 e 10 unità di capacità di scrittura. + Dopo aver creato l'obiettivo scalabile, il programma sviluppa configurazioni di monitoraggio obiettivi. La policy cerca di mantenere un rapporto obiettivo del 50% tra capacità di scrittura utilizzata e capacità di scrittura assegnata. + In seguito, il programma crea la policy di dimensionamento in base alla configurazione di monitoraggio obiettivi. **Nota** Quando rimuovi manualmente una tabella o una replica globale di una tabella, non rimuovi automaticamente gli obiettivi scalabili, le politiche di scalabilità o gli allarmi associati. 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 ] Il programma richiede che venga specificato un Amazon Resource Name (ARN) per un ruolo collegato ai servizi di Application Auto Scaling valido. (Ad esempio: `arn:aws:iam::122517410325:role/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`.) Nel programma seguente, sostituisci `SERVICE_ROLE_ARN_GOES_HERE` con l'ARN reale. ``` 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()); } } } ``` ------ ## Disabilitazione di Application Auto Scaling per una tabella Nel programma seguente, il processo precedente viene invertito. Esso rimuove la policy di scalabilità automatica e annulla la registrazione dell'obiettivo scalabile. ------ #### [ 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()); } } } ``` ------