AWS Cloud9 tidak lagi tersedia untuk pelanggan baru. Pelanggan yang sudah ada AWS Cloud9 dapat terus menggunakan layanan seperti biasa. [Pelajari selengkapnya](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Amazon DynamoDB tutorial untuk AWS Cloud9
Tutorial ini memungkinkan Anda untuk mengatur lingkungan AWS Cloud9 pengembangan untuk bekerja dengan Amazon DynamoDB.
DynamoDB adalah layanan basis data NoSQL yang terkelola penuh. Anda dapat menggunakan DynamoDB untuk membuat tabel basis data yang dapat menyimpan dan mengambil data dalam jumlah berapa pun, dan melayani tingkat lalu lintas permintaan apapun. DynamoDB secara otomatis menyebarkan data dan lalu lintas untuk tabel melalui sejumlah server yang cukup untuk menangani kapasitas permintaan yang ditentukan dan jumlah data yang disimpan, sambil mempertahankan performa yang konsisten dan cepat. Untuk informasi selengkapnya, lihat [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) di situs web. AWS
Membuat sampel ini dapat mengakibatkan biaya ke AWS akun Anda. Ini termasuk kemungkinan biaya untuk layanan seperti Amazon EC2 dan DynamoDB. Untuk informasi selengkapnya, lihat [Harga Amazon EC2](https://aws.amazon.com/ec2/pricing/) dan [Harga Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
[Untuk informasi tentang penawaran AWS database tambahan, lihat [Amazon Relational Database Service (RDS), Amazon[, ElastiCache](https://aws.amazon.com/elasticache/) dan Amazon Redshift](https://aws.amazon.com/rds/) di situs web.](https://aws.amazon.com/redshift/) AWS Lihat juga [AWS Database Migration Service](https://aws.amazon.com/dms/) di situs web AWS .
+ [Prasyarat](#sample-dynamodb-prereqs)
+ [Langkah 1: Instal dan konfigurasikan AWS CLI, yang AWS CloudShell, atau keduanya di lingkungan Anda](#sample-dynamodb-cli-setup)
+ [Langkah 2: Buat tabel](#sample-dynamodb-create-table)
+ [Langkah 3: Tambahkan item ke tabel](#sample-dynamodb-add-item)
+ [Langkah 4: Tambahkan beberapa item ke tabel](#sample-dynamodb-add-items)
+ [Langkah 5: Buat indeks sekunder global](#sample-dynamodb-create-index)
+ [Langkah 6: Dapatkan item dari tabel](#sample-dynamodb-get-items)
+ [Langkah 7: Bersihkan](#sample-dynamodb-clean-up)
## Prasyarat
Sebelum Anda menggunakan sampel ini, pastikan pengaturan Anda memenuhi persyaratan berikut:
+ **Anda harus memiliki lingkungan pengembangan AWS Cloud9 EC2 yang ada.** Contoh ini mengasumsikan bahwa Anda sudah memiliki lingkungan EC2 yang terhubung ke instans Amazon EC2 yang menjalankan Amazon Linux atau Server. Ubuntu Jika Anda memiliki jenis lingkungan atau sistem operasi yang berbeda, Anda mungkin perlu menyesuaikan petunjuk sampel ini untuk menyiapkan alat terkait. Untuk informasi selengkapnya, lihat [Menciptakan lingkungan di AWS Cloud9](create-environment.md).
+ **Anda memiliki AWS Cloud9 IDE untuk lingkungan yang ada sudah terbuka.** Saat Anda membuka lingkungan, AWS Cloud9 buka IDE untuk lingkungan itu di browser web Anda. Untuk informasi selengkapnya, lihat [Membuka lingkungan di AWS Cloud9](open-environment.md).
## Langkah 1: Instal dan konfigurasikan AWS CLI, yang AWS CloudShell, atau keduanya di lingkungan Anda
Pada langkah ini, Anda menggunakan AWS Cloud9 IDE untuk menginstal dan mengkonfigurasi AWS CLI, AWS CloudShell, atau keduanya di lingkungan Anda sehingga Anda dapat menjalankan perintah untuk berinteraksi dengan DynamoDB. Kemudian Anda menggunakan AWS CLI untuk menjalankan perintah basic DynamoDB untuk menguji pemasangan dan konfigurasi Anda.
1. Untuk mengatur manajemen kredensyal untuk AWS CLI atau AWS CloudShell dan untuk menginstal AWS CLI, AWS CloudShell, atau keduanya di lingkungan Anda, ikuti Langkah 1 dan 2 di [AWS CLI dan AWS CloudShell Contoh](sample-aws-cli.md), lalu kembali ke topik ini. Jika Anda sudah menginstal dan mengkonfigurasi AWS CLI AWS CloudShell, the, atau keduanya di lingkungan Anda, Anda tidak perlu melakukannya lagi.
1. Uji instalasi dan konfigurasi, aws-shell AWS CLI, atau keduanya dengan menjalankan **`list-tables`**perintah DynamoDB dari sesi terminal di lingkungan Anda untuk membuat daftar tabel DynamoDB yang ada, jika ada. Untuk memulai sesi terminal baru, pada bilah menu, pilih **Windows**, **Terminal Baru**.
```
aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables # For the aws-shell.
```
**catatan**
Sepanjang sampel ini, jika Anda menggunakan aws-shell, hilangkan `aws` dari setiap perintah yang dimulai dengan `aws`. Untuk memulai aws-shell, jalankan perintah ** `aws-shell` **. Untuk berhenti menggunakan aws-shell, jalankan perintah ** `.exit` ** atau ** `.quit` **.
Jika perintah ini berhasil, perintah ini akan mengeluarkan larik `TableNames` yang berisi daftar tabel DynamoDB yang sudah ada yang mungkin sudah Anda miliki. Jika Anda belum memiliki tabel DynamoDB, larik `TableNames` akan kosong.
```
{
"TableNames": []
}
```
Jika Anda memiliki tabel DynamoDB, larik `TableNames` berisi daftar nama tabel.
## Langkah 2: Buat Tabel
Pada langkah ini, Anda membuat tabel di DynamoDB dan menentukan nama tabel, tata letak, kunci primer sederhana, dan pengaturan throughput data.
Tabel sampel ini, dengan nama `Weather`, berisi informasi tentang prakiraan cuaca untuk beberapa kota di Amerika Serikat. Tabel menyimpan jenis informasi berikut (di DynamoDB, setiap bagian informasi dikenal sebagai *atribut*):
+ ID kota unik yang diperlukan (`CityID`)
+ Tanggal prakiraan yang diperlukan (`Date`)
+ Nama kota (`City`)
+ Nama negara (`State`)
+ Prakiraan kondisi cuaca (`Conditions`)
+ Prakiraan suhu (`Temperatures`)
+ Prakiraan tinggi, dalam derajat Fahrenheit (`HighF`)
+ Prakiraan rendah, dalam derajat Fahrenheit (`LowF`)
Untuk membuat tabel, dalam sesi terminal di AWS Cloud9 IDE, jalankan perintah DynamoDB **`create-table`**.
```
aws dynamodb create-table \
--table-name Weather \
--attribute-definitions \
AttributeName=CityID,AttributeType=N AttributeName=Date,AttributeType=S \
--key-schema \
AttributeName=CityID,KeyType=HASH AttributeName=Date,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
```
Dalam perintah ini:
+ `--table-name` mewakili nama tabel (`Weather` dalam sampel ini). Nama tabel harus unik di setiap AWS Wilayah di AWS akun Anda.
+ `--attribute-definitions` mewakili atribut yang digunakan untuk mengidentifikasi item tabel secara unik. Setiap item tabel ini diidentifikasi secara unik dengan kombinasi atribut `ID` numerik dan atribut `Date` yang direpresentasikan sebagai string berformat ISO-8601.
+ `--key-schema` mewakili skema kunci tabel ini. Tabel memiliki kunci primer komposit `CityID` dan `Date`. Ini berarti bahwa setiap item tabel harus memiliki nilai atribut `CityID` dan nilai atribut `Date`, tetapi tidak ada dua item dalam tabel yang dapat memiliki nilai atribut `CityID` dan nilai atribut `Date` yang sama.
+ `--provisioned-throughput` mewakili kapasitas baca-tulis tabel. DynamoDB memungkinkan hingga 5 bacaan konsisten per detik untuk item berukuran hingga 4 KB, atau hingga 5 bacaan akhir konsisten per detik untuk item berukuran hingga 4 KB. DynamoDB juga memungkinkan hingga 5 penulisan per detik untuk item berukuran hingga 1 KB.
**catatan**
Menyetel throughput yang disediakan lebih tinggi dapat mengakibatkan biaya tambahan ke akun Anda. AWS
Untuk informasi selengkapnya tentang ini dan perintah DynamoDB lainnya, lihat [dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html) di *Referensi Perintah AWS CLI *.
Jika perintah ini berhasil, ini akan menampilkan informasi ringkasan tentang tabel baru yang sedang dibuat. Untuk mengonfirmasi bahwa tabel berhasil dibuat, jalankan perintah DynamoDB ** `describe-table` **, dengan menentukan nama tabel (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Ketika tabel berhasil dibuat, nilai `TableStatus` berubah dari `CREATING` menjadi `ACTIVE`. Jangan lanjutkan melewati langkah ini sampai tabel berhasil dibuat.
## Langkah 3: Tambahkan item ke tabel
Pada langkah ini, Anda menambahkan item ke tabel yang baru saja Anda buat.
1. Buat file dengan nama `weather-item.json` dengan konten berikut ini. Untuk membuat file baru, pada bilah menu, pilih **File**, **File Baru**. Untuk menyimpan file, pilih **File**, **Simpan**.
```
{
"CityID": { "N": "1" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "46" }
}
}
}
```
Dalam kode ini, `N` mewakili nilai atribut yang berupa angka. `S` adalah nilai atribut string. `M` adalah atribut pemetaan, yang merupakan himpunan pasangan atribut-nilai. Anda harus menentukan tipe data atribut setiap kali Anda bekerja dengan item. Untuk tipe data atribut tambahan yang tersedia, lihat [Tipe Data](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) di *Panduan Developer Amazon DynamoDB*.
1. Jalankan perintah DynamoDB ** `put-item` **, tentukan nama tabel (`--table-name`) dan jalur ke item berformat JSON (`--item`).
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
Jika perintah berhasil, itu berjalan tanpa kesalahan, dan tidak ada pesan konfirmasi yang ditampilkan.
1. Untuk mengonfirmasi bahwa tabel berhasil dibuat, jalankan perintah DynamoDB ** `scan` **, dengan menentukan nama tabel (`--table-name`).
```
aws dynamodb scan --table-name Weather
```
Jika perintah berhasil, ringkasan informasi tentang tabel dan item yang baru saja Anda tambahkan akan ditampilkan.
## Langkah 4: Tambahkan beberapa item ke tabel
Pada langkah ini, Anda menambahkan beberapa item lagi ke tabel `Weather`.
1. Buat file dengan nama `more-weather-items.json` dengan konten berikut ini.
```
{
"Weather": [
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "52" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Thunderstorms" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "51" },
"LowF": { "N": "41" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain Showers" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "39" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "40" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Partly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "54" },
"LowF": { "N": "37" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Mostly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "53" },
"LowF": { "N": "37" }
}
}
}
}
}
]
}
```
Dalam kode ini, 8 objek `Item` mendefinisikan 8 item untuk ditambahkan ke tabel, mirip dengan satu item yang ditentukan pada langkah sebelumnya. Namun, saat Anda menjalankan perintah DynamoDB ** `batch-write-item` ** di langkah berikutnya, Anda harus menyediakan objek berformat JSON yang menyertakan setiap objek `Item` di objek `PutRequest` yang berisi. Kemudian Anda harus menyertakan objek `PutRequest` tersebut dalam larik induk yang memiliki nama yang sama dengan tabel.
1. Jalankan perintah DynamoDB ** `batch-write-item` **, dengan menetapkan jalur ke item berformat JSON untuk ditambahkan (`--request-items`).
```
aws dynamodb batch-write-item \
--request-items file://more-weather-items.json
```
Jika perintah berhasil, ini akan menampilkan pesan berikut, mengonfirmasi bahwa item berhasil ditambahkan.
```
{
"UnprocessedItems": {}
}
```
1. Untuk mengonfirmasi konten tabel saat ini, jalankan kembali perintah DynamoDB ** `scan` **.
```
aws dynamodb scan --table-name Weather
```
Jika perintah berhasil, 9 item sekarang ditampilkan.
## Langkah 5: Buat indeks sekunder global
Menjalankan perintah DynamoDB ** `scan` ** untuk mendapatkan informasi tentang item bisa lambat, terutama karena ukuran tabel bertambah atau jika jenis informasi yang ingin Anda dapatkan rumit. Anda dapat membuat satu atau beberapa indeks sekunder untuk mempercepat dan mempermudah mendapatkan informasi. Dalam langkah ini, Anda mempelajari tentang dua jenis indeks sekunder yang didukung DynamoDB untuk melakukan hal itu. Ini dikenal sebagai *indeks sekunder lokal* dan *indeks sekunder global*. Kemudian Anda membuat indeks sekunder global.
Untuk memahami tipe indeks sekunder ini, Anda harus terlebih dahulu mengetahui tentang kunci primer, yang secara unik mengidentifikasi item tabel. DynamoDB mendukung *kunci primer sederhana* atau *kunci primer komposit*. Kunci primer sederhana memiliki satu atribut, dan nilai atribut itu harus unik untuk setiap item dalam tabel. Atribut ini juga dikenal sebagai *kunci partisi* (atau *atribut hash*), yang dapat digunakan DynamoDB untuk mempartisi item untuk akses yang lebih cepat. Sebuah tabel juga dapat memiliki kunci primer komposit, yang berisi dua atribut. Atribut pertama adalah kunci partisi, dan yang kedua adalah *kunci pengurutan* (juga dikenal sebagai *atribut rentang*). Dalam tabel dengan kunci primer komposit, dua item dapat memiliki nilai kunci partisi yang sama, tetapi mereka juga tidak dapat memiliki nilai kunci pengurutan yang sama. Tabel `Weather` memiliki kunci primer komposit.
Indeks sekunder lokal memiliki kunci partisi yang sama dengan tabel itu sendiri, tetapi tipe indeks ini dapat memiliki kunci pengurutan yang berbeda. Indeks sekunder global dapat memiliki kunci partisi dan kunci pengurutan yang keduanya berbeda dari tabel itu sendiri.
Misalnya, Anda sudah dapat menggunakan kunci primer untuk mengakses item `Weather` dengan `CityID`. Untuk mengakses item `Weather` dengan `State`, Anda dapat membuat indeks sekunder lokal yang memiliki kunci partisi `CityID` (harus sama dengan tabel itu sendiri) dan kunci pengurutan `State`. Untuk mengakses item `Weather` dengan `City`, Anda dapat membuat indeks sekunder global yang memiliki kunci partisi `City` dan kunci pengurutan `Date`.
Anda dapat membuat indeks sekunder lokal hanya saat Anda membuat tabel. Karena tabel `Weather` sudah ada, Anda tidak dapat menambahkan indeks sekunder lokal apa pun ke dalamnya. Namun, Anda dapat menambahkan indeks sekunder global. Berlatih menambahkan satu sekarang.
**catatan**
Membuat indeks sekunder dapat mengakibatkan biaya tambahan ke akun AWS Anda.
1. Buat file dengan nama `weather-global-index.json` dengan konten berikut ini.
```
[
{
"Create": {
"IndexName": "weather-global-index",
"KeySchema": [
{
"AttributeName": "City",
"KeyType": "HASH"
},
{
"AttributeName": "Date",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"State",
"Conditions",
"Temperatures"
]
},
"ProvisionedThroughput": {
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
}
}
}
]
```
Dalam kode ini:
+ Nama indeks sekunder global adalah `weather-global-index`.
+ Atribut `City` adalah kunci partisi (atribut hash), dan atribut `Date` adalah kunci pengurutan (atribut range).
+ `Projection` mendefinisikan atribut yang akan diambil secara default (selain atribut hash dan atribut rentang apa pun) untuk setiap item yang cocok dengan pencarian tabel yang menggunakan indeks ini. Dalam sampel ini, atribut `State`, `Conditions`, `HighF` (bagian dari `Temperatures`), dan `LowF` (juga bagian dari `Temperatures`) (serta atribut `City` dan `Date`) diambil untuk setiap item yang cocok.
+ Mirip dengan tabel, indeks sekunder global harus menentukan pengaturan throughput yang disediakan.
+ Pengaturan `IndexName`, `KeySchema`, `Projection`, dan `ProvisionedThroughput` harus dimuat dalam objek `Create`, yang menentukan indeks sekunder global yang akan dibuat saat Anda menjalankan perintah DynamoDB ** `update-table` ** di langkah berikutnya.
1. Jalankan perintah DynamoDB ** `update-table` **.
```
aws dynamodb update-table \
--table-name Weather \
--attribute-definitions \
AttributeName=City,AttributeType=S AttributeName=Date,AttributeType=S \
--global-secondary-index-updates file://weather-global-index.json
```
Dalam perintah ini:
+ `--table-name` adalah nama tabel yang akan diperbarui.
+ `--attribute-definitions` adalah atribut untuk dimasukkan dalam indeks. Kunci partisi selalu dicantumkan pertama, dan kunci pengurutan apa pun selalu dicantumkan kedua.
+ `--global-secondary-index-updates` adalah jalur ke file yang mendefinisikan indeks sekunder global.
Jika perintah ini berhasil, ini akan menampilkan informasi ringkasan tentang indeks sekunder global baru yang sedang dibuat. Untuk mengonfirmasi bahwa indeks sekunder global berhasil dibuat, jalankan perintah DynamoDB ** `describe-table` **, dengan menentukan nama tabel (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Ketika indeks sekunder global berhasil dibuat, nilai `TableStatus` berubah dari `UPDATING` ke `ACTIVE`, dan nilai `IndexStatus` berubah dari `CREATING` ke `ACTIVE`. Jangan lanjutkan melewati langkah ini sampai indeks sekunder global berhasil dibuat. Ini dapat memakan waktu beberapa menit.
## Langkah 6: Dapatkan item dari tabel
Ada banyak cara untuk mendapatkan item dari tabel. Dalam langkah ini, Anda mendapatkan item dengan menggunakan kunci primer tabel, dengan menggunakan atribut tabel lainnya, dan dengan menggunakan indeks sekunder global.
### Untuk mendapatkan satu item dari tabel berdasarkan nilai kunci primer item
Jika Anda mengetahui nilai kunci primer item, Anda bisa mendapatkan item yang cocok dengan menjalankan perintah DynamoDB ** `get-item` **, ** `scan` **, atau ** `query` **. Berikut ini adalah perbedaan utama dalam perintah ini:
+ ** `get-item` ** mengembalikan satu set atribut untuk item dengan kunci primer yang diberikan.
+ ** `scan` ** mengembalikan satu atau lebih item dan atribut item dengan mengakses setiap item dalam tabel atau indeks sekunder.
+ ** `query` ** menemukan item berdasarkan nilai kunci primer. Anda dapat membuat kueri tabel atau indeks sekunder apa pun yang memiliki kunci primer komposit (kunci partisi dan kunci pengurutan).
Dalam sampel ini, berikut adalah cara menggunakan masing-masing perintah ini untuk mendapatkan item yang berisi nilai atribut `CityID` dari `1` dan nilai atribut `Date` dari `2017-04-12`.
1. Untuk menjalankan perintah DynamoDB ** `get-item` **, tentukan nama tabel (`--table-name`), nilai kunci primer (`--key`), dan nilai atribut untuk item yang akan ditampilkan (`--projection-expression`). Karena `Date` adalah kata kunci yang dicadangkan di DynamoDB, Anda juga harus memberikan alias untuk nilai atribut `Date` (`--expression-attribute-names`). (`State` juga merupakan kata kunci yang dicadangkan, jadi Anda akan melihat alias yang disediakan untuknya di langkah selanjutnya.)
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }' \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
Dalam perintah ini dan perintah lainnya, untuk menampilkan semua atribut item, jangan sertakan `--projection-expression`. Dalam contoh ini, karena Anda tidak menyertakan `--projection-expression`, Anda juga tidak perlu menyertakan `--expression-attribute-names`.
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'
```
1. Untuk menjalankan perintah DynamoDB ** `scan` **, tentukan:
+ Nama tabel (`--table-name`).
+ Pencarian untuk dijalankan (`--filter-expression`).
+ Kriteria pencarian untuk digunakan (`--expression-attribute-values`).
+ Jenis atribut yang akan ditampilkan untuk item yang cocok (`--select`).
+ Nilai atribut untuk item yang akan ditampilkan (`--projection-expression`).
+ Jika ada atribut Anda yang menggunakan kata kunci yang dicadangkan di DynamoDB, alias untuk atribut tersebut (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
1. Untuk menjalankan perintah DynamoDB ** `query` **, tentukan:
+ Nama tabel (`--table-name`).
+ Pencarian untuk dijalankan (`--key-condition-expression`).
+ Nilai atribut yang akan digunakan dalam pencarian (`--expression-attribute-values`).
+ Jenis atribut yang akan ditampilkan untuk item yang cocok (`--select`).
+ Nilai atribut untuk item yang akan ditampilkan (`--projection-expression`).
+ Jika ada atribut Anda yang menggunakan kata kunci yang dicadangkan di DynamoDB, alias untuk atribut tersebut (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--key-condition-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
Perhatikan bahwa perintah ** `scan` ** diperlukan untuk memindai semua 9 item untuk mendapatkan hasilnya, sedangkan perintah ** `query` ** hanya perlu memindai 1 item.
### Untuk mendapatkan beberapa item dari tabel berdasarkan nilai kunci primer item
Jika Anda mengetahui nilai kunci primer item, Anda bisa mendapatkan item yang cocok dengan menjalankan perintah DynamoDB ** `batch-get-item` **. Dalam sampel ini, berikut cara mendapatkan item yang berisi nilai atribut `CityID` dari `3` dan nilai atribut `Date` dari `2017-04-13` atau `2017-04-14`.
Jalankan perintah DynamoDB ** `batch-get-item` **, dengan menetapkan jalur ke file yang menjelaskan item yang akan diperoleh (`--request-items`).
```
aws dynamodb batch-get-item --request-items file://batch-get-item.json
```
Untuk sampel ini, kode dalam file `batch-get-item.json` menentukan untuk mencari tabel `Weather` untuk item dengan `CityID` dari `3` dan `Date` dari `2017-04-13` atau `2017-04-14`. Untuk setiap item yang ditemukan, nilai atribut untuk `City`, `State`, `Date`, dan `HighF` (bagian dari `Temperatures`) ditampilkan, jika ada.
```
{
"Weather" : {
"Keys": [
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" }
},
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" }
}
],
"ProjectionExpression": "City, #S, #D, Temperatures.HighF",
"ExpressionAttributeNames": { "#S": "State", "#D": "Date" }
}
}
```
### Untuk mendapatkan semua item yang cocok dari sebuah tabel
Jika Anda mengetahui sesuatu tentang nilai atribut dalam tabel, Anda bisa mendapatkan item yang cocok dengan menjalankan perintah DynamoDB ** `scan` **. Dalam sampel ini, berikut cara mendapatkan tanggal saat nilai atribut `Conditions` berisi `Sunny` dan nilai atribut `HighF` (bagian dari `Temperatures`) lebih besar dari `53`.
Jalankan perintah DynamoDB ** `scan` **, dengan menetapkan:
+ Nama tabel (`--table-name`).
+ Pencarian untuk dijalankan (`--filter-expression`).
+ Kriteria pencarian untuk digunakan (`--expression-attribute-values`).
+ Jenis atribut yang akan ditampilkan untuk item yang cocok (`--select`).
+ Nilai atribut untuk item yang akan ditampilkan (`--projection-expression`).
+ Jika ada atribut Anda yang menggunakan kata kunci yang dicadangkan di DynamoDB, alias untuk atribut tersebut (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression \
"(contains (Conditions, :sun)) and (Temperatures.HighF > :h)" \
--expression-attribute-values \
'{ ":sun": { "S" : "Sunny" }, ":h": { "N" : "53" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
### Untuk mendapatkan semua item yang cocok dari indeks sekunder global
Untuk mencari menggunakan indeks sekunder global, gunakan perintah DynamoDB ** `query` **. Dalam sampel ini, berikut adalah cara menggunakan indeks sekunder `weather-global-index` untuk mendapatkan kondisi prakiraan kota bernama `Portland` untuk tanggal `2017-04-13` dan `2017-04-14`.
Jalankan perintah DynamoDB ** `query` **, dengan menetapkan:
+ Nama tabel (`--table-name`).
+ Nama indeks sekunder global (`--index-name`).
+ Pencarian untuk dijalankan (`--key-condition-expression`).
+ Nilai atribut yang akan digunakan dalam pencarian (`--expression-attribute-values`).
+ Jenis atribut yang akan ditampilkan untuk item yang cocok (`--select`).
+ Jika ada atribut Anda yang menggunakan kata kunci yang dicadangkan di DynamoDB, alias untuk atribut tersebut (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--index-name weather-global-index \
--key-condition-expression "(City = :city) and (#D between :date1 and :date2)" \
--expression-attribute-values \
'{ ":city": { "S" : "Portland" }, ":date1": { "S": "2017-04-13" }, ":date2": { "S": "2017-04-14" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
## Langkah 7: Bersihkan
Untuk mencegah tagihan yang sedang berlangsung ke AWS akun Anda setelah selesai menggunakan sampel ini, Anda harus menghapus tabel. Menghapus tabel akan menghapus indeks sekunder global juga. Anda juga harus menghapus lingkungan Anda.
Untuk menghapus tabel, jalankan perintah DynamoDB ** `delete-table` **, dengan menentukan nama tabel (`--table-name`).
```
aws dynamodb delete-table --table-name Weather
```
Jika perintah berhasil, informasi tentang tabel ditampilkan, termasuk nilai `TableStatus` dari `DELETING`.
Untuk mengonfirmasi bahwa tabel berhasil dihapus, jalankan perintah DynamoDB ** `describe-table` **, dengan menentukan nama tabel (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Jika tabel berhasil dihapus, pesan yang berisi frasa `Requested resource not found` ditampilkan.
Untuk menghapus lingkungan Anda, lihat [Menghapus Lingkungan](delete-environment.md).