Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Mengelola kapasitas throughput secara otomatis dengan penskalaan otomatis DynamoDB Banyak beban kerja basis data yang bersifat siklik, sementara yang lainnya sulit diprediksi sebelumnya. Sebagai salah satu contoh, perhatikan aplikasi jejaring sosial yang sebagian besar penggunanya aktif pada siang hari. Basis data harus mampu menangani aktivitas siang hari, tetapi tingkat throughput yang sama tidak diperlukan pada malam hari. Sebagai contoh lainnya, pertimbangkan aplikasi game seluler baru yang tidak disangka mengalami adopsi yang begitu cepat. Jika game menjadi terlalu populer, game tersebut bisa melampaui sumber daya basis data yang tersedia, sehingga performanya lambat dan pelanggan menjadi tidak puas. Beban kerja semacam ini kerap perlu dinaikkan atau dikurangi skala sumber daya basis datanya secara manual guna merespons berbagai tingkat penggunaan. Penskalaan otomatis Amazon DynamoDB menggunakan layanan Application AWS Auto Scaling untuk menyesuaikan kapasitas throughput yang disediakan secara dinamis atas nama Anda, sebagai respons terhadap pola lalu lintas yang sebenarnya. Hal ini memungkinkan tabel atau indeks sekunder global (GSI) untuk meningkatkan kapasitas baca dan tulis yang disediakan untuk menangani peningkatan lalu lintas yang tiba-tiba, tanpa pembatasan. Ketika beban kerja berkurang, Application Auto Scaling dapat menurunkan throughput agar Anda tidak membayar kapasitas tersedia yang tidak terpakai. **catatan** Jika Anda menggunakan Konsol Manajemen AWS untuk membuat tabel atau indeks sekunder global, DynamoDB auto scaling diaktifkan secara default. Anda dapat memodifikasi pengaturan penskalaan otomatis kapan saja. Untuk informasi selengkapnya, lihat [Menggunakan penskalaan Konsol Manajemen AWS otomatis with DynamoDB](AutoScaling.Console.md). Saat Anda menghapus tabel atau replika tabel global, target terukur, kebijakan penskalaan, atau CloudWatch alarm yang terkait tidak akan dihapus secara otomatis dengannya. Dengan Application Auto Scaling, Anda membuat *kebijakan penskalaan* untuk tabel atau indeks sekunder global. Kebijakan penskalaan menentukan apakah Anda ingin menskalakan kapasitas baca atau tulis (atau keduanya), serta pengaturan unit kapasitas minimum dan maksimum yang tersedia untuk tabel atau indeks. Kebijakan penskalaan juga berisi *pemanfaatan target*—persentase throughput tersedia yang dikonsumsi pada suatu titik waktu. Application Auto Scaling menggunakan algoritma *pelacakan target* untuk menyesuaikan throughput tersedia dari tabel (atau indeks) ke atas atau ke bawah sebagai respons atas beban kerja aktual, sehingga pemanfaatan kapasitas aktual tetap atau mendekati pemanfaatan target Anda. Output DynamoDB menggunakan throughput yang disediakan untuk periode satu menit. Penskalaan otomatis terpicu ketika kapasitas yang Anda konsumsi melanggar pemanfaatan target yang dikonfigurasi selama dua menit berturut-turut. CloudWatch alarm mungkin memiliki penundaan singkat hingga beberapa menit sebelum memicu penskalaan otomatis. Penundaan ini memastikan evaluasi CloudWatch metrik yang akurat. Jika lonjakan throughput yang dikonsumsi terpisah lebih dari satu menit, penskalaan otomatis mungkin tidak terpicu. Demikian pula, peristiwa penurunan skala dapat terjadi ketika 15 titik data berturut-turut lebih rendah dari pemanfaatan target. Dalam kedua kasus tersebut, setelah pemicu penskalaan otomatis, [UpdateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html)API dipanggil. Kemudian dibutuhkan beberapa menit untuk memperbarui kapasitas yang disediakan untuk tabel atau indeks. Selama periode ini, setiap permintaan yang melebihi kapasitas tabel yang disediakan sebelumnya akan dibatasi. **penting** Anda tidak dapat menyesuaikan jumlah titik data yang akan dilanggar untuk memicu alarm yang mendasarinya (meskipun nomor saat ini dapat berubah di masa mendatang). Anda dapat menetapkan nilai pemanfaatan target penskalaan otomatis antara 20 dan 90 persen untuk kapasitas baca dan tulis Anda. **catatan** Selain tabel, penskalaan otomatis DynamoDB juga mendukung indeks sekunder global. Setiap indeks sekunder global memiliki kapasitas throughput tersedia miliknya sendiri, terpisah dari tabel dasarnya. Ketika Anda membuat kebijakan penskalaan untuk indeks sekunder global, Application Auto Scaling menyesuaikan pengaturan throughput tersedia untuk indeks guna memastikan bahwa pemanfaatan aktual tetap atau mendekati rasio pemanfaatan yang Anda inginkan. ## Cara kerja penskalaan otomatis DynamoDB **catatan** Untuk memulai penggunaan penskalaan otomatis DynamoDB dengan cepat, lihat [Menggunakan penskalaan Konsol Manajemen AWS otomatis with DynamoDB](AutoScaling.Console.md). Diagram berikut memberikan gambaran umum tingkat tinggi tentang bagaimana penskalaan otomatis DynamoDB mengelola kapasitas throughput untuk tabel. ![\[DynamoDB auto scaling menyesuaikan kapasitas throughput tabel untuk memenuhi permintaan.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/auto-scaling.png) Langkah-langkah berikut meringkas proses penskalaan otomatis seperti yang ditunjukkan pada diagram sebelumnya: 1. Anda membuat kebijakan Application Auto Scaling untuk tabel DynamoDB Anda. 1. DynamoDB menerbitkan metrik kapasitas yang dikonsumsi ke Amazon. CloudWatch 1. Jika kapasitas konsumsi tabel melebihi pemanfaatan target Anda (atau jatuh di bawah target) untuk jangka waktu tertentu, Amazon CloudWatch memicu alarm. Anda dapat melihat alarm di konsol dan menerima pemberitahuan menggunakan Amazon Simple Notification Service (Amazon SNS). 1. CloudWatch Alarm memanggil Application Auto Scaling untuk mengevaluasi kebijakan penskalaan Anda. 1. Application Auto Scaling mengeluarkan permintaan `UpdateTable` untuk menyesuaikan throughput tersedia pada tabel Anda. 1. DynamoDB memproses permintaan `UpdateTable`, secara dinamis menaikkan (atau menurunkan) kapasitas throughput tersedia pada tabel agar mendekati pemanfaatan target Anda. Untuk memahami cara kerja penskalaan otomatis DynamoDB, misalnya Anda memiliki tabel bernama `ProductCatalog`. Tabel ini dimuat secara massal dengan data secara jarang, sehingga tidak mengalami aktivitas tulis yang sangat banyak. Namun, tabel tersebut memang mengalami aktivitas baca yang tinggi dan bervariasi dari waktu ke waktu. Dengan memantau CloudWatch metrik Amazon`ProductCatalog`, Anda menentukan bahwa tabel memerlukan 1.200 unit kapasitas baca (untuk menghindari DynamoDB membatasi permintaan baca saat aktivitas mencapai puncaknya). Anda juga menentukan bahwa `ProductCatalog` memerlukan minimum 150 unit kapasitas baca, ketika lalu lintas baca berada pada titik terendah. Untuk informasi selengkapnya tentang mencegah throttling, lihat [Pemecahan masalah pelambatan di Amazon DynamoDB](TroubleshootingThrottling.md). Dalam kisaran 150 sampai 1.200 unit kapasitas baca, Anda memutuskan bahwa pemanfaatan target sebesar 70 persen akan sesuai untuk tabel `ProductCatalog`. *Pemanfaatan target* adalah rasio unit kapasitas yang dikonsumsi terhadap unit kapasitas yang disediakan, dinyatakan dengan persentase. Application Auto Scaling menggunakan algoritma pelacakan targetnya untuk memastikan bahwa kapasitas baca yang disediakan dari `ProductCatalog` disesuaikan sesuai kebutuhan sehingga pemanfaatan tetap atau mendekati 70 persen. **catatan** Penskalaan otomatis DynamoDB memodifikasi pengaturan throughput yang disediakan hanya ketika beban kerja sebenarnya tetap dinaikkan atau ditekan untuk jangka waktu berkelanjutan selama beberapa menit. Algoritma pelacakan target Application Auto Scaling berusaha menjaga pemanfaatan target ini pada atau mendekati nilai yang Anda pilih dalam jangka panjang. Lonjakan aktivitas yang mendadak dan berdurasi singkat diakomodasi oleh kapasitas lonjakan bawaan tabel. Untuk informasi selengkapnya, lihat [Kapasitas lonjakan](burst-adaptive-capacity.md#burst-capacity). Untuk mengaktifkan penskalaan otomatis DynamoDB untuk tabel `ProductCatalog`, Anda membuat kebijakan penskalaan. Kebijakan ini menentukan hal berikut: + Tabel atau indeks sekunder global yang ingin Anda kelola + Jenis kapasitas mana yang akan dikelola (kapasitas baca atau kapasitas tulis) + Batas atas dan bawah untuk pengaturan throughput yang tersedia + Pemanfaatan target Anda Saat Anda membuat kebijakan penskalaan, Application Auto Scaling akan membuat sepasang alarm CloudWatch Amazon atas nama Anda. Setiap pasangan merepresentasikan batas atas dan bawah untuk pengaturan throughput tersedia Anda. CloudWatch Alarm ini dipicu ketika penggunaan tabel yang sebenarnya menyimpang dari penggunaan target Anda untuk jangka waktu yang berkelanjutan. Ketika salah satu CloudWatch alarm dipicu, Amazon SNS mengirimi Anda pemberitahuan (jika Anda telah mengaktifkannya). CloudWatch Alarm kemudian memanggil Application Auto Scaling, yang pada gilirannya memberi tahu DynamoDB untuk menyesuaikan kapasitas yang disediakan tabel ke atas atau ke bawah `ProductCatalog` sebagaimana mestinya. Selama acara penskalaan, AWS Config dibebankan per item konfigurasi yang direkam. Ketika peristiwa penskalaan terjadi, empat CloudWatch alarm dibuat untuk setiap peristiwa auto-scaling baca dan tulis: alarm:, dan ProvisionedCapacity alarm:,. ProvisionedCapacityLow ProvisionedCapacityHigh ConsumedCapacity AlarmHigh AlarmLow Ini menghasilkan total delapan alarm. Oleh karena itu, AWS Config catat delapan item konfigurasi untuk setiap peristiwa penskalaan. **catatan** Anda juga dapat menjadwalkan penskalaan DynamoDB Anda sehingga terjadi pada waktu-waktu tertentu. Pelajari langkah-langkah dasar [di sini](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html). ## Catatan penggunaan Sebelum Anda mulai menggunakan penskalaan otomatis DynamoDB, ketahui hal berikut: + Penskalaan otomatis DynamoDB dapat meningkatkan kapasitas baca atau kapasitas tulis sesering yang diperlukan, sesuai dengan kebijakan penskalaan otomatis Anda. Semua kuota DynamoDB tetap berlaku, seperti yang dijelaskan dalam [Kuota di Amazon DynamoDB](ServiceQuotas.md). + Penskalaan otomatis DynamoDB tidak mencegah Anda untuk memodifikasi sendiri pengaturan throughput yang tersedia. Penyesuaian manual ini tidak memengaruhi CloudWatch alarm yang ada yang terkait dengan penskalaan otomatis DynamoDB. + Jika Anda mengaktifkan penskalaan otomatis DynamoDB untuk tabel yang memiliki satu atau beberapa indeks global sekunder, kami sangat menyarankan Anda agar juga menerapkan penskalaan otomatis yang seragam untuk indeks tersebut. Hal ini akan membantu memastikan performa yang lebih baik untuk penulisan dan pembacaan tabel, serta membantu menghindari throttling. Anda dapat mengaktifkan penskalaan otomatis dengan memilih **Terapkan pengaturan yang sama untuk indeks sekunder global** di Konsol Manajemen AWS. Untuk informasi selengkapnya, lihat [Mengaktifkan penskalaan otomatis DynamoDB pada tabel yang ada](AutoScaling.Console.md#AutoScaling.Console.ExistingTable). + Saat Anda menghapus tabel atau replika tabel global, target yang dapat diskalakan terkait, kebijakan penskalaan, atau CloudWatch alarm tidak akan dihapus secara otomatis dengannya. + Saat membuat GSI untuk tabel yang ada, penskalaan otomatis tidak diaktifkan untuk GSI. Anda harus mengelola kapasitas secara manual saat GSI sedang dibangun. Setelah backfill pada GSI selesai dan mencapai status aktif, penskalaan otomatis akan beroperasi seperti biasa. # Menggunakan penskalaan Konsol Manajemen AWS otomatis with DynamoDB Saat Anda menggunakan Konsol Manajemen AWS untuk membuat tabel baru, penskalaan otomatis Amazon DynamoDB diaktifkan untuk tabel tersebut secara default. Anda juga dapat menggunakan konsol untuk mengaktifkan penskalaan otomatis untuk tabel yang ada, memodifikasi pengaturan penskalaan otomatis, atau menonaktifkan penskalaan otomatis. **catatan** Untuk fitur yang lebih canggih seperti menyetel waktu cooldown scale-in dan scale-out, gunakan AWS Command Line Interface () untuk AWS CLI mengelola penskalaan otomatis DynamoDB. Untuk informasi selengkapnya, lihat [Menggunakan AWS CLI untuk mengelola penskalaan otomatis DynamoDB](AutoScaling.CLI.md). **Topics** + [Sebelum memulai: Memberikan izin pengguna untuk penskalaan otomatis DynamoDB](#AutoScaling.Permissions) + [Membuat tabel baru dengan penskalaan otomatis diaktifkan](#AutoScaling.Console.NewTable) + [Mengaktifkan penskalaan otomatis DynamoDB pada tabel yang ada](#AutoScaling.Console.ExistingTable) + [Melihat aktivitas penskalaan otomatis di konsol](#AutoScaling.Console.ViewingActivities) + [Memodifikasi atau menonaktifkan pengaturan penskalaan otomatis DynamoDB](#AutoScaling.Console.Modifying) ## Sebelum memulai: Memberikan izin pengguna untuk penskalaan otomatis DynamoDB Di AWS Identity and Access Management (IAM), kebijakan AWS terkelola `DynamoDBFullAccess` memberikan izin yang diperlukan untuk menggunakan konsol DynamoDB. Namun, untuk penskalaan otomatis DynamoDB, pengguna memerlukan izin tambahan. **penting** Untuk menghapus tabel yang diaktifkan untuk penskalaan otomatis, diperlukan izin `application-autoscaling:*`. Kebijakan AWS terkelola `DynamoDBFullAccess` mencakup izin tersebut. **Untuk menyiapkan pengguna untuk akses konsol DynamoDB dan penskalaan otomatis DynamoDB, buat peran dan tambahkan kebijakan Access ke peran tersebut. AmazonDynamo DBFull** Kemudian tetapkan peran ke seorang pengguna. ## Membuat tabel baru dengan penskalaan otomatis diaktifkan **catatan** Penskalaan otomatis DynamoDB memerlukan kehadiran peran yang ditautkan dengan layanan (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) yang melakukan tindakan penskalaan otomatis atas nama Anda. Peran ini dibuat secara otomatis untuk Anda. Untuk informasi selengkapnya, lihat [Peran terkait layanan untuk Application Auto](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) Scaling di Panduan Pengguna *Application Auto Scaling*. **Cara membuat tabel baru dengan penskalaan otomatis diaktifkan** 1. Buka konsol DynamoDB di. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Pilih **Buat tabel**. 1. Pada halaman **Buat tabel**, masukkan **nama Tabel** dan detail kunci utama. 1. Jika Anda memilih **Pengaturan default**, penskalaan otomatis diaktifkan di tabel baru. Jika tidak, pilih **Sesuaikan pengaturan** dan lakukan hal berikut untuk menentukan pengaturan khusus untuk tabel: 1. Untuk **kelas Table**, pertahankan pilihan default **DynamoDB Standard**. 1. Untuk **pengaturan kapasitas baca/tulis**, pertahankan pilihan default **Provisioned**, lalu lakukan hal berikut: 1. **Untuk **kapasitas Baca**, pastikan **penskalaan Otomatis** diatur ke Aktif.** 1. **Untuk **kapasitas Tulis**, pastikan **penskalaan Otomatis** diatur ke Aktif.** 1. Untuk **kapasitas Baca dan kapasitas** **Tulis**, tetapkan kebijakan penskalaan yang Anda inginkan untuk tabel dan, secara opsional, semua indeks sekunder global tabel. + **Unit kapasitas minimum** – Masukkan batas bawah Anda untuk rentang penskalaan otomatis. + **Unit kapasitas maksimum** – Masukkan batas atas Anda untuk rentang penskalaan otomatis. + **Pemanfaatan target** – Masukkan persentase pemanfaatan target Anda untuk tabel. **catatan** Jika Anda membuat indeks sekunder global untuk tabel baru, kapasitas indeks pada saat pembuatan akan sama dengan kapasitas tabel dasar Anda. Anda dapat mengubah kapasitas indeks dalam pengaturan tabel setelah membuat tabel. 1. Pilih **Buat tabel**. Ini membuat tabel Anda dengan parameter penskalaan otomatis yang Anda tentukan. ## Mengaktifkan penskalaan otomatis DynamoDB pada tabel yang ada **catatan** Penskalaan otomatis DynamoDB memerlukan kehadiran peran yang ditautkan dengan layanan (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) yang melakukan tindakan penskalaan otomatis atas nama Anda. Peran ini dibuat secara otomatis untuk Anda. Untuk informasi selengkapnya. lihat [Peran tertaut layanan untuk Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html). **Cara mengaktifkan penskalaan otomatis DynamoDB untuk tabel yang ada** 1. Buka konsol DynamoDB di. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Di panel navigasi di sisi kiri konsol, pilih **Tabel**. 1. Pilih tabel tempat Anda ingin mengaktifkan penskalaan otomatis, lalu lakukan hal berikut: 1. Pilih tab **Pengaturan tambahan**. 1. Di bagian **Kapasitas baca/tulis**, pilih **Edit**. 1. Di bagian **Mode kapasitas**, pilih **Disediakan**. 1. Di bagian **Kapasitas tabel**, atur **Penskalaan otomatis** ke **Aktif** untuk **Kapasitas baca**, **Kapasitas tulis**, atau keduanya. Untuk setiap pengaturan tersebut, tetapkan kebijakan penskalaan yang Anda inginkan untuk tabel, dan semua indeks sekunder global tabel (opsional). + **Unit kapasitas minimum** – Masukkan batas bawah Anda untuk rentang penskalaan otomatis. + **Unit kapasitas maksimum** – Masukkan batas atas Anda untuk rentang penskalaan otomatis. + **Pemanfaatan target** – Masukkan persentase pemanfaatan target Anda untuk tabel. + **Gunakan pengaturan kapasitas read/write kapasitas yang sama untuk semua indeks sekunder global** — Pilih apakah indeks sekunder global harus menggunakan kebijakan penskalaan otomatis yang sama dengan tabel dasar. **catatan** Untuk kinerja terbaik, kami sarankan Anda mengaktifkan **Gunakan pengaturan read/write kapasitas yang sama untuk semua indeks sekunder global**. Opsi ini memungkinkan penskalaan otomatis DynamoDB untuk menskalakan semua indeks sekunder global pada tabel dasar secara seragam. Ini termasuk indeks sekunder global yang ada, dan setiap indeks lain yang Anda buat untuk tabel ini nantinya. Dengan mengaktifkan opsi ini, Anda tidak dapat menetapkan kebijakan penskalaan pada indeks sekunder global individual. 1. Jika pengaturan sudah sesuai keinginan Anda, pilih **Simpan**. ## Melihat aktivitas penskalaan otomatis di konsol Saat aplikasi Anda mendorong lalu lintas baca dan tulis ke tabel Anda, penskalaan otomatis DynamoDB secara dinamis memodifikasi pengaturan throughput tabel. Amazon CloudWatch melacak kapasitas yang disediakan dan dikonsumsi, peristiwa yang dibatasi, latensi, dan metrik lainnya untuk semua tabel DynamoDB dan indeks sekunder Anda. Untuk melihat metrik ini di konsol DynamoDB, pilih tabel yang ingin Anda kerjakan, lalu pilih tab **Monitor**. Untuk membuat tampilan metrik tabel yang dapat disesuaikan, pilih **Lihat** semua dalam. CloudWatch ## Memodifikasi atau menonaktifkan pengaturan penskalaan otomatis DynamoDB Anda dapat menggunakan Konsol Manajemen AWS untuk memodifikasi pengaturan penskalaan otomatis DynamoDB Anda. Untuk melakukan hal ini, buka tab **Pengaturan tambahan** untuk tabel Anda, lalu pilih **Edit** di bagian **Kapasitas baca/tulis**. Untuk informasi selengkapnya tentang pengaturan ini, lihat [Mengaktifkan penskalaan otomatis DynamoDB pada tabel yang ada](#AutoScaling.Console.ExistingTable). # Menggunakan AWS CLI untuk mengelola penskalaan otomatis DynamoDB Alih-alih menggunakan Konsol Manajemen AWS, Anda dapat menggunakan AWS Command Line Interface (AWS CLI) untuk mengelola penskalaan otomatis Amazon DynamoDB. Tutorial di bagian ini menunjukkan cara menginstal dan mengonfigurasi AWS CLI untuk mengelola penskalaan otomatis DynamoDB. Dalam tutorial ini, Anda melakukan hal-hal berikut: + Buat tabel DynamoDB bernama `TestTable`. Pengaturan throughput awal adalah 5 unit kapasitas baca dan 5 unit kapasitas tulis. + Buat kebijakan Application Auto Scaling untuk `TestTable`. Kebijakan ini bertujuan untuk mempertahankan rasio target sebesar 50 persen antara kapasitas tulis yang dikonsumsi dan kapasitas tulis yang disediakan. Kisaran untuk metrik ini adalah antara 5 dan 10 unit kapasitas tulis. (Application Auto Scaling tidak diizinkan untuk menyesuaikan throughput di luar kisaran ini.) + Jalankan program Python untuk mendorong lalu lintas tulis ke `TestTable`. Ketika rasio target melebihi 50 persen untuk jangka waktu yang berkelanjutan, Application Auto Scaling memberi tahu DynamoDB untuk menyesuaikan throughput `TestTable` ke atas guna mempertahankan pemanfaatan target sebesar 50 persen. + Verifikasi bahwa DynamoDB telah berhasil menyesuaikan kapasitas tulis yang disediakan untuk `TestTable`. **catatan** Anda juga dapat menjadwalkan penskalaan DynamoDB Anda sehingga terjadi pada waktu-waktu tertentu. Pelajari langkah-langkah dasar [di sini](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html). **Topics** + [Sebelum Anda mulai](#AutoScaling.CLI.BeforeYouBegin) + [Langkah 1: Buat tabel DynamoDB](#AutoScaling.CLI.CreateTable) + [Langkah 2: Daftarkan target yang dapat diskalakan](#AutoScaling.CLI.RegisterScalableTarget) + [Langkah 3: Buat kebijakan penskalaan](#AutoScaling.CLI.CreateScalingPolicy) + [Langkah 4: Dorong lalu lintas tulis ke TestTable](#AutoScaling.CLI.DriveTraffic) + [Langkah 5: Lihat tindakan Application Auto Scaling](#AutoScaling.CLI.ViewCWAlarms) + [(Opsional) Langkah 6: Hapus](#AutoScaling.CLI.CleanUp) ## Sebelum Anda mulai Selesaikan tugas berikut sebelum memulai tutorial. ### Instal AWS CLI Jika belum, Anda harus menginstal dan mengonfigurasi AWS CLI. Untuk melakukannya, ikuti petunjuk berikut di *Panduan Pengguna AWS Command Line Interface *: + [Menginstal AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) + [Mengonfigurasi AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) ### Instal Python Anda perlu menjalankan program Python di bagian tutorial ini (lihat [Langkah 4: Dorong lalu lintas tulis ke TestTable](#AutoScaling.CLI.DriveTraffic)). Jika belum menginstalnya, Anda dapat [mengunduh Python](https://www.python.org/downloads). ## Langkah 1: Buat tabel DynamoDB Pada langkah ini, Anda menggunakan AWS CLI to create`TestTable`. Kunci primer terdiri dari `pk` (kunci partisi) dan `sk` (kunci urutan). Kedua atribut ini berjenis `Number`. Pengaturan throughput awal adalah 5 unit kapasitas baca dan 5 unit kapasitas tulis. 1. Gunakan AWS CLI perintah berikut untuk membuat tabel. ``` 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. Untuk memeriksa status tabel, gunakan perintah berikut. ``` aws dynamodb describe-table \ --table-name TestTable \ --query "Table.[TableName,TableStatus,ProvisionedThroughput]" ``` Tabel siap digunakan saat statusnya `ACTIVE`. ## Langkah 2: Daftarkan target yang dapat diskalakan Selanjutnya Anda mendaftar kapasitas tulis tabel sebagai target yang dapat diskalakan dengan Application Auto Scaling. Hal ini memungkinkan Application Auto Scaling untuk menyesuaikan kapasitas tulis yang disediakan untuk *TestTable*, tetapi hanya dalam kisaran 5-10 unit kapasitas. **catatan** Penskalaan otomatis DynamoDB memerlukan kehadiran peran tertaut layanan (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) yang melakukan tindakan penskalaan otomatis atas nama Anda. Peran ini dibuat secara otomatis untuk Anda. Untuk informasi selengkapnya, lihat [Peran tertaut layanan untuk Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) dalam *Panduan Pengguna Application Auto Scaling*. 1. Gunakan perintah berikut untuk mendaftarkan target yang dapat diskalakan. ``` 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. Untuk memverifikasi pendaftaran, gunakan perintah berikut. ``` aws application-autoscaling describe-scalable-targets \ --service-namespace dynamodb \ --resource-id "table/TestTable" ``` **catatan** Anda juga dapat mendaftarkan target yang dapat diskalakan terhadap indeks sekunder global. Sebagai contoh, untuk indeks sekunder global ("test-index"), ID sumber daya dan argumen dimensi yang dapat diskalakan diperbarui dengan sesuai. ``` 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 ``` ## Langkah 3: Buat kebijakan penskalaan Pada langkah ini, Anda membuat kebijakan penskalaan untuk `TestTable`. Kebijakan ini mendefinisikan detail di mana Application Auto Scaling dapat menyesuaikan throughput yang disediakan pada tabel, dan tindakan yang harus diambil ketika melakukannya. Anda mengaitkan kebijakan ini dengan target yang dapat diskalakan yang Anda tetapkan pada langkah sebelumnya (unit kapasitas tulis untuk tabel `TestTable`). Kebijakan tersebut berisi elemen berikut: + `PredefinedMetricSpecification`—Metrik yang dapat disesuaikan oleh Application Auto Scaling. Untuk DynamoDB, nilai berikut adalah nilai yang valid untuk `PredefinedMetricType`: + `DynamoDBReadCapacityUtilization` + `DynamoDBWriteCapacityUtilization` + `ScaleOutCooldown`—Jumlah waktu minimum (dalam detik) antara setiap peristiwa Application Auto Scaling yang meningkatkan throughput yang disediakan. Parameter ini memungkinkan Application Auto Scaling untuk secara terus-menerus, tetapi tanpa agresivitas, meningkatkan throughput sebagai respons terhadap beban kerja dunia nyata. Pengaturan default untuk `ScaleOutCooldown` adalah 0. + `ScaleInCooldown`—Jumlah waktu minimum (dalam detik) antara setiap peristiwa Application Auto Scaling yang mengurangi throughput yang disediakan. Parameter ini memungkinkan Application Auto Scaling untuk mengurangi throughput secara bertahap dan terprediksi. Pengaturan default untuk `ScaleInCooldown` adalah 0. + `TargetValue`—Application Auto Scaling memastikan bahwa rasio kapasitas yang dikonsumsi terhadap kapasitas yang disediakan tetap atau mendekati nilai ini. Anda mendefinisikan `TargetValue` sebagai persentase. **catatan** Untuk lebih memahami cara kerja `TargetValue`, misalkan Anda memiliki sebuah tabel dengan pengaturan throughput yang disediakan sebanyak 200 unit kapasitas tulis. Anda memutuskan untuk membuat kebijakan penskalaan untuk tabel ini, dengan `TargetValue` sebesar 70 persen. Sekarang anggaplah Anda mulai mendorong lalu lintas tulis ke tabel sehingga throughput tulis aktual adalah sebesar 150 unit kapasitas. consumed-to-provisionedRasionya sekarang (150/200), atau 75 persen. Rasio ini melebihi target Anda, sehingga Application Auto Scaling meningkatkan kapasitas tulis yang disediakan menjadi 215, sehingga rasionya (150 / 215), atau 69,77 persen—sedekat mungkin dengan `TargetValue`, tetapi tidak melebihinya. Untuk `TestTable`, Anda mengatur `TargetValue` ke 50 persen. Application Auto Scaling menyesuaikan throughput yang disediakan tabel dalam kisaran 5-10 unit kapasitas (lihat[Langkah 2: Daftarkan target yang dapat diskalakan](#AutoScaling.CLI.RegisterScalableTarget)) sehingga rasio tetap pada atau mendekati 50 persen. consumed-to-provisioned Anda mengatur nilai untuk `ScaleOutCooldown` dan `ScaleInCooldown` ke 60 detik. 1. Buat file bernama `scaling-policy.json` dengan isi berikut ini. ``` { "PredefinedMetricSpecification": { "PredefinedMetricType": "DynamoDBWriteCapacityUtilization" }, "ScaleOutCooldown": 60, "ScaleInCooldown": 60, "TargetValue": 50.0 } ``` 1. Gunakan AWS CLI perintah berikut untuk membuat kebijakan. ``` 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. Dalam output, perhatikan bahwa Application Auto Scaling telah menciptakan dua CloudWatch alarm Amazon — masing-masing untuk batas atas dan bawah rentang target penskalaan. 1. Gunakan AWS CLI perintah berikut untuk melihat detail selengkapnya tentang kebijakan penskalaan. ``` aws application-autoscaling describe-scaling-policies \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --policy-name "MyScalingPolicy" ``` 1. Dalam output, verifikasi bahwa pengaturan kebijakan sesuai dengan spesifikasi Anda dari [Langkah 2: Daftarkan target yang dapat diskalakan](#AutoScaling.CLI.RegisterScalableTarget) dan [Langkah 3: Buat kebijakan penskalaan](#AutoScaling.CLI.CreateScalingPolicy). ## Langkah 4: Dorong lalu lintas tulis ke TestTable Sekarang Anda dapat menguji kebijakan penskalaan Anda dengan menulis data ke `TestTable`. Untuk melakukan ini, jalankan program Python. 1. Buat file bernama `bulk-load-test-table.py` dengan isi berikut ini. ``` 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. Masukkan perintah berikut untuk menjalankan program. `python bulk-load-test-table.py` Kapasitas tulis yang disediakan untuk `TestTable` sangat rendah (5 unit kapasitas tulis), sehingga terkadang mengalami kegagalan karena throttling tulis. Ini adalah perilaku yang diharapkan. Biarkan program terus berjalan sementara Anda melanjutkan ke langkah berikutnya. ## Langkah 5: Lihat tindakan Application Auto Scaling Pada langkah ini, Anda melihat tindakan Application Auto Scaling yang dimulai atas nama Anda. Anda juga memverifikasi bahwa Application Auto Scaling telah memperbarui kapasitas tulis yang disediakan untuk `TestTable`. 1. Masukkan perintah berikut untuk melihat tindakan Application Auto Scaling. ``` aws application-autoscaling describe-scaling-activities \ --service-namespace dynamodb ``` Jalankan kembali perintah ini sesekali, sementara program Python sedang berjalan. (Perlu beberapa menit hingga kebijakan penskalaan Anda diinvokasi.) Anda akan melihat output berikut. ``` ... { "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" }, ... ``` Hal ini menunjukkan bahwa Application Auto Scaling telah mengeluarkan permintaan `UpdateTable` untuk DynamoDB. 1. Masukkan perintah berikut untuk memverifikasi bahwa DynamoDB meningkatkan kapasitas tulis tabel. ``` aws dynamodb describe-table \ --table-name TestTable \ --query "Table.[TableName,TableStatus,ProvisionedThroughput]" ``` `WriteCapacityUnits` semestinya telah diskalakan dari `5` ke `10`. ## (Opsional) Langkah 6: Hapus Dalam tutorial ini, Anda telah membuat beberapa sumber daya. Anda dapat menghapus sumber daya ini jika sudah tidak membutuhkannya lagi. 1. Hapus kebijakan penskalaan untuk `TestTable`. ``` aws application-autoscaling delete-scaling-policy \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" \ --policy-name "MyScalingPolicy" ``` 1. Batalkan pendaftaran target yang dapat diskalakan. ``` aws application-autoscaling deregister-scalable-target \ --service-namespace dynamodb \ --resource-id "table/TestTable" \ --scalable-dimension "dynamodb:table:WriteCapacityUnits" ``` 1. Hapus tabel `TestTable`. ``` aws dynamodb delete-table --table-name TestTable ``` # Menggunakan AWS SDK untuk mengonfigurasi penskalaan otomatis pada tabel Amazon DynamoDB Selain menggunakan Konsol Manajemen AWS dan AWS Command Line Interface (AWS CLI), Anda dapat menulis aplikasi yang berinteraksi dengan penskalaan otomatis Amazon DynamoDB. Bagian ini berisi dua program Java yang dapat Anda gunakan untuk menguji fungsi ini: + `EnableDynamoDBAutoscaling.java` + `DisableDynamoDBAutoscaling.java` ## Mengaktifkan Application Auto Scaling untuk suatu tabel Program berikut menunjukkan contoh penyiapan kebijakan penskalaan otomatis untuk tabel DynamoDB (`TestTable`). Hal ini berjalan sebagai berikut: + Program mendaftarkan unit kapasitas tulis sebagai target yang dapat diskalakan untuk `TestTable`. Kisaran untuk metrik ini adalah antara 5 dan 10 unit kapasitas tulis. + Setelah target yang dapat diskalakan dibuat, program ini membangun konfigurasi pelacakan target. Kebijakan ini bertujuan untuk mempertahankan rasio target sebesar 50 persen antara kapasitas tulis yang dikonsumsi dan kapasitas tulis yang disediakan. + Program ini kemudian membuat kebijakan penskalaan berdasarkan konfigurasi pelacakan target. **catatan** Saat menghapus tabel atau replika tabel global secara manual, Anda tidak secara otomatis menghapus target, kebijakan penskalaan, atau alarm terkait yang dapat diskalakan. 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 ] Program ini meminta Anda untuk menyediakan Amazon Resource Name (ARN) untuk peran yang tertaut dengan layanan Application Auto Scaling. (Misalnya: `arn:aws:iam::122517410325:role/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`.) Pada program berikut, ganti `SERVICE_ROLE_ARN_GOES_HERE` dengan ARN yang sebenarnya. ``` 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()); } } } ``` ------ ## Menonaktifkan Application Auto Scaling untuk suatu tabel Program berikut membalikkan proses sebelumnya. Program akan menghapus kebijakan penskalaan otomatis dan kemudian membatalkan pendaftaran target yang dapat diskalakan. ------ #### [ 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()); } } } ``` ------