Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan AWS CLI
Bagian ini memberikan gambaran menyeluruh tentang penggunaan umum, fitur umum, dan opsi yang tersedia di AWS Command Line Interface (AWS CLI), melampaui detail yang tercakup dalam [Menggunakan titik akhir di AWS CLI](cli-configure-endpoints.md) bagian Konfigurasi.
Panduan ini menggali aspek-aspek mendasar dari menulis AWS CLI perintah, termasuk struktur dasar, pemformatan, dan kemampuan penyaringan. Dengan memahami elemen-elemen inti ini, Anda akan dapat membuat perintah yang secara tepat menargetkan sumber daya dan tindakan yang Anda butuhkan, tanpa perlu menavigasi konsol berbasis web yang kompleks.
Selain itu, ini menyoroti konten bantuan dan dokumentasi yang tersedia untuk AWS CLI. Dari bantuan baris perintah bawaan hingga komprehensif [AWS CLI versi 2 panduan referensi](https://docs.aws.amazon.com/cli/latest/reference/), Anda akan memiliki akses ke informasi untuk membantu Anda menjelajahi fitur dan kemampuan AWS CLI.
Untuk contoh Layanan AWS spesifik dan kasus penggunaan, lihat [Contoh untuk AWS CLI](cli-chap-code-examples.md) atau [referensi AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/reference/). Ini memberikan informasi spesifik perintah dan menunjukkan contoh tentang cara memanfaatkan AWS CLI untuk berbagai Layanan AWS.
**catatan**
Secara default, AWS CLI mengirim permintaan ke Layanan AWS dengan menggunakan HTTPS pada port TCP 443. Untuk memastikan keberhasilan penggunaan AWS CLI, Anda harus dapat membuat koneksi keluar pada port ini.
**Topics**
+ [Mengakses bantuan dan sumber daya untuk AWS CLI](cli-usage-help.md)
+ [Struktur perintah di AWS CLI](cli-usage-commandstructure.md)
+ [Menentukan nilai parameter dalam AWS CLI](cli-usage-parameters.md)
+ [Mengaktifkan dan menggunakan command prompt di AWS CLI](cli-usage-parameters-prompting.md)
+ [Mengontrol output perintah di AWS CLI](cli-usage-output.md)
+ [Kode pengembalian baris perintah di AWS CLI](cli-usage-returncodes.md)
+ [Menggunakan wizard khusus untuk menjalankan perintah interaktif di AWS CLI](cli-usage-wizard.md)
+ [Membuat dan menggunakan alias di AWS CLI](cli-usage-alias.md)
+ [Memecahkan masalah kesalahan untuk AWS CLI](cli-chap-troubleshooting.md)
# Mengakses bantuan dan sumber daya untuk AWS CLI
Topik ini menjelaskan cara mengakses konten bantuan untuk AWS Command Line Interface (AWS CLI).
**Topics**
+ [Perintah AWS CLI bantuan bawaan](#cli-usage-help-command)
+ [AWS CLI panduan referensi](#cli-reference)
+ [Dokumentasi API](#api-reference)
+ [Memecahkan masalah kesalahan](#help-tshoot)
+ [Bantuan tambahan](#help-additional)
## Perintah AWS CLI bantuan bawaan
Anda bisa mendapatkan bantuan dengan perintah apa pun saat menggunakan AWS Command Line Interface (AWS CLI). Untuk melakukannya, cukup ketik `help` di akhir nama perintah.
Misalnya, perintah berikut menampilkan bantuan untuk AWS CLI opsi umum dan perintah tingkat atas yang tersedia.
```
$ aws help
```
Perintah berikut menampilkan perintah khusus Amazon Elastic Compute Cloud (Amazon EC2) yang tersedia.
```
$ aws ec2 help
```
Contoh berikut menampilkan bantuan terperinci untuk operasi Amazon EC2`DescribeInstances`. Bantuan tersebut mencakup deskripsi parameter inputnya, filter yang tersedia, dan apa yang disertakan sebagai output. Ini juga mencakup contoh yang menunjukkan cara mengetik variasi umum dari perintah.
```
$ aws ec2 describe-instances help
```
`2.31.0`Pada versi Tampilan untuk `help` perintah dikonfigurasi oleh `cli_help_output` pengaturan, dan memiliki nilai-nilai berikut:
+ **(default`terminal`)** - Buka halaman manual di terminal.
+ `browser`- Buka halaman manual sebagai file HTML lokal di browser default Anda. Pemberitahuan dicetak ke terminal Anda ketika browser default Anda sedang dibuka, dan pesan kesalahan jika AWS CLI tidak dapat membuka browser Anda.
+ `url`- Cetak URL ke Panduan AWS CLI Referensi online untuk versi yang telah AWS CLI Anda instal. Pengaturan untuk paging sisi klien, seperti variabel `AWS_PAGER` lingkungan, dihormati.
Konten bantuan untuk setiap perintah dibagi menjadi enam bagian:
Nama
Nama perintah.
```
NAME
describe-instances -
```
Deskripsi
Deskripsi operasi API yang dipanggil perintah.
```
DESCRIPTION
Describes one or more of your instances.
If you specify one or more instance IDs, Amazon EC2 returns information
for those instances. If you do not specify instance IDs, Amazon EC2
returns information for all relevant instances. If you specify an
instance ID that is not valid, an error is returned. If you specify an
instance that you do not own, it is not included in the returned
results.
...
```
Sinopsis
Sintaks dasar untuk menggunakan perintah dan opsinya. Jika opsi ditampilkan dalam tanda kurung siku, itu opsional, memiliki nilai default, atau memiliki opsi alternatif yang dapat Anda gunakan.
```
SYNOPSIS
describe-instances
[--dry-run | --no-dry-run]
[--instance-ids ]
[--filters ]
[--cli-input-json ]
[--starting-token ]
[--page-size ]
[--max-items ]
[--generate-cli-skeleton]
```
Misalnya, `describe-instances` memiliki perilaku default yang menjelaskan ***semua*** instance di akun saat ini dan AWS Wilayah. Anda dapat secara opsional menentukan daftar `instance-ids` untuk menggambarkan satu atau beberapa contoh; `dry-run` adalah bendera Boolean opsional yang tidak mengambil nilai. Untuk menggunakan bendera Boolean, tentukan nilai yang ditampilkan, dalam kasus ini `--dry-run` atau`--no-dry-run`. Demikian juga, `--generate-cli-skeleton` tidak mengambil nilai. Jika ada kondisi pada penggunaan opsi, mereka dijelaskan di `OPTIONS` bagian, atau ditampilkan dalam contoh.
Opsi
Deskripsi masing-masing opsi yang ditunjukkan dalam sinopsis.
```
OPTIONS
--dry-run | --no-dry-run (boolean)
Checks whether you have the required permissions for the action,
without actually making the request, and provides an error response.
If you have the required permissions, the error response is DryRun-
Operation . Otherwise, it is UnauthorizedOperation .
--instance-ids (list)
One or more instance IDs.
Default: Describes all your instances.
...
```
Contoh
Contoh yang menunjukkan penggunaan perintah dan opsinya. Jika tidak ada contoh yang tersedia untuk perintah atau kasus penggunaan yang Anda butuhkan, mintalah satu menggunakan tautan umpan balik di halaman ini, atau dalam referensi AWS CLI perintah di halaman bantuan untuk perintah tersebut.
```
EXAMPLES
To describe an Amazon EC2 instance
Command:
aws ec2 describe-instances --instance-ids i-5203422c
To describe all instances with the instance type m1.small
Command:
aws ec2 describe-instances --filters "Name=instance-type,Values=m1.small"
To describe all instances with an Owner tag
Command:
aws ec2 describe-instances --filters "Name=tag-key,Values=Owner"
...
```
Output
Deskripsi masing-masing bidang dan tipe data yang disertakan dalam respons dari AWS.
Untuk`describe-instances`, outputnya adalah daftar objek reservasi, yang masing-masing berisi beberapa bidang dan objek yang berisi informasi tentang instance yang terkait dengannya. Informasi ini berasal dari [dokumentasi API untuk tipe data reservasi](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_Reservation.html) yang digunakan oleh Amazon EC2.
```
OUTPUT
Reservations -> (list)
One or more reservations.
(structure)
Describes a reservation.
ReservationId -> (string)
The ID of the reservation.
OwnerId -> (string)
The ID of the AWS account that owns the reservation.
RequesterId -> (string)
The ID of the requester that launched the instances on your
behalf (for example, AWS Management Console or Auto Scaling).
Groups -> (list)
One or more security groups.
(structure)
Describes a security group.
GroupName -> (string)
The name of the security group.
GroupId -> (string)
The ID of the security group.
Instances -> (list)
One or more instances.
(structure)
Describes an instance.
InstanceId -> (string)
The ID of the instance.
ImageId -> (string)
The ID of the AMI used to launch the instance.
State -> (structure)
The current state of the instance.
Code -> (integer)
The low byte represents the state. The high byte
is an opaque internal value and should be ignored.
...
```
Ketika AWS CLI merender output ke JSON, itu menjadi array objek reservasi, mirip dengan contoh berikut.
```
{
"Reservations": [
{
"OwnerId": "012345678901",
"ReservationId": "r-4c58f8a0",
"Groups": [],
"RequesterId": "012345678901",
"Instances": [
{
"Monitoring": {
"State": "disabled"
},
"PublicDnsName": "ec2-52-74-16-12.us-west-2.compute.amazonaws.com",
"State": {
"Code": 16,
"Name": "running"
},
...
```
Setiap objek reservasi berisi bidang yang menjelaskan reservasi dan array objek instance, masing-masing dengan bidangnya sendiri (misalnya,`PublicDnsName`) dan objek (misalnya,`State`) yang mendeskripsikannya.
**Pengguna Windows**
Anda dapat *menyalurkan* (\$1) output dari perintah bantuan ke `more` perintah untuk melihat file bantuan satu halaman pada satu waktu. Tekan spasi atau **PgDn**untuk melihat lebih banyak dokumen, dan **q** untuk berhenti.
```
C:\> aws ec2 describe-instances help | more
```
## AWS CLI panduan referensi
File bantuan berisi tautan yang tidak dapat dilihat atau dinavigasi dari baris perintah. Anda dapat melihat dan berinteraksi dengan tautan ini dengan menggunakan [referensi AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/reference/index.html). Referensi juga berisi konten bantuan untuk semua AWS CLI perintah. Deskripsi disajikan untuk navigasi dan tampilan yang mudah di layar seluler, tablet, atau desktop.
## Dokumentasi API
Semua perintah dalam AWS CLI sesuai dengan permintaan yang dibuat ke API publik AWS layanan. Setiap layanan dengan API publik memiliki referensi API yang dapat ditemukan di halaman beranda layanan di [situs web AWS Dokumentasi](https://docs.aws.amazon.com/). Konten untuk referensi API bervariasi berdasarkan bagaimana API dibangun dan protokol mana yang digunakan. Biasanya, referensi API berisi informasi terperinci tentang operasi yang didukung oleh API, data yang dikirim ke dan dari layanan, dan kondisi kesalahan apa pun yang dapat dilaporkan oleh layanan.
**Bagian Dokumentasi API**
+ **Tindakan** — Informasi terperinci tentang setiap operasi dan parameternya (termasuk kendala pada panjang atau konten, dan nilai default). Ini mencantumkan kesalahan yang dapat terjadi untuk operasi ini. Setiap operasi sesuai dengan subperintah di. AWS CLI
+ **Tipe Data** — Informasi terperinci tentang struktur yang mungkin diperlukan perintah sebagai parameter, atau dikembalikan sebagai respons terhadap permintaan.
+ **Parameter Umum** — Informasi terperinci tentang parameter yang dibagikan oleh semua tindakan untuk layanan.
+ **Kesalahan Umum** — Informasi terperinci tentang kesalahan yang dapat dikembalikan oleh salah satu operasi layanan.
Nama dan ketersediaan setiap bagian dapat bervariasi, tergantung pada layanan.
**Layanan khusus CLIs**
Beberapa layanan memiliki CLI terpisah yang berasal dari sebelum satu AWS CLI dibuat untuk bekerja dengan semua layanan. Khusus layanan ini CLIs memiliki dokumentasi terpisah yang ditautkan dari halaman dokumentasi layanan. Dokumentasi untuk layanan khusus CLIs tidak berlaku untuk. AWS CLI
## Memecahkan masalah kesalahan
Untuk bantuan mendiagnosis dan memperbaiki AWS CLI kesalahan, lihat[Memecahkan masalah kesalahan untuk AWS CLI](cli-chap-troubleshooting.md).
## Bantuan tambahan
Untuk bantuan tambahan AWS CLI terkait masalah Anda, kunjungi [AWS CLI komunitas](https://github.com/aws/aws-cli/issues) di *GitHub*.
# Struktur perintah di AWS CLI
Topik ini mencakup bagaimana AWS Command Line Interface (AWS CLI) perintah terstruktur, dan bagaimana menggunakan perintah tunggu.
**Topics**
+ [Struktur komando](#cli-usage-commandstructure-structure.title)
+ [Tunggu perintah](#cli-usage-commandstructure-wait)
## Struktur komando
AWS CLI Menggunakan struktur multipart pada baris perintah yang harus ditentukan dalam urutan ini:
1. Panggilan dasar ke `aws` program.
1. *Perintah* tingkat atas, yang biasanya sesuai dengan AWS layanan yang didukung oleh. AWS CLI
1. *Subperintah* yang menentukan operasi mana yang harus dilakukan.
1. AWS CLI Opsi umum atau parameter yang diperlukan oleh operasi. Anda dapat menentukan ini dalam urutan apa pun selama mereka mengikuti tiga bagian pertama. Jika parameter eksklusif ditentukan beberapa kali, hanya *nilai terakhir* yang berlaku.
```
$ aws [options and parameters]
```
Parameter dapat mengambil berbagai jenis nilai input, seperti angka, string, daftar, peta, dan struktur JSON. Apa yang didukung tergantung pada perintah dan subperintah yang Anda tentukan.
### Contoh
**Amazon S3**
Contoh berikut mencantumkan semua bucket Amazon S3 Anda.
```
$ aws s3 ls
2018-12-11 17:08:50 amzn-s3-demo-bucket1
2018-12-14 14:55:44 amzn-s3-demo-bucket2
```
Untuk informasi selengkapnya tentang perintah Amazon S3, lihat di Referensi *AWS CLI Perintah*.
**AWS CloudFormation**
Contoh perintah berikut mengubah nama tumpukan cloudformation menjadi. *my-change-set*
```
$ aws cloudformation create-change-set --stack-name my-stack --change-set-name my-change-set
```
Untuk informasi selengkapnya tentang AWS CloudFormation perintah, lihat di *Referensi AWS CLI Perintah*.
## Tunggu perintah
Beberapa AWS layanan memiliki `wait` perintah yang tersedia. Setiap perintah yang menggunakan `aws wait` biasanya menunggu sampai perintah selesai sebelum pindah ke langkah berikutnya. Ini sangat berguna untuk perintah multibagian atau skrip, karena Anda dapat menggunakan perintah tunggu untuk mencegah pindah ke langkah berikutnya jika perintah tunggu gagal.
AWS CLI Menggunakan struktur multipart pada baris perintah untuk `wait` perintah yang harus ditentukan dalam urutan ini:
1. Panggilan dasar ke `aws` program.
1. *Perintah* tingkat atas, yang biasanya sesuai dengan AWS layanan yang didukung oleh. AWS CLI
1. `wait`Perintah.
1. *Subperintah* yang menentukan operasi mana yang harus dilakukan.
1. Opsi atau parameter CLI umum yang diperlukan oleh operasi. Anda dapat menentukan ini dalam urutan apa pun selama mereka mengikuti tiga bagian pertama. Jika parameter eksklusif ditentukan beberapa kali, hanya *nilai terakhir* yang berlaku.
```
$ aws wait [options and parameters]
```
Parameter dapat mengambil berbagai jenis nilai input, seperti angka, string, daftar, peta, dan struktur JSON. Apa yang didukung tergantung pada perintah dan subperintah yang Anda tentukan.
**catatan**
Tidak semua layanan AWS mendukung `wait` perintah. Lihat [versi 2 panduan referensi](https://docs.aws.amazon.com/cli/latest/reference/index.html) untuk melihat apakah layanan Anda mendukung `wait` perintah.
### Contoh
**AWS CloudFormation**
Contoh perintah berikut berhenti dan dilanjutkan hanya setelah dapat mengonfirmasi bahwa *my-change-set* perubahan yang disetel di *my-stack* tumpukan siap dijalankan.
```
$ aws cloudformation wait change-set-create-complete --stack-name my-stack --change-set-name my-change-set
```
Untuk informasi selengkapnya tentang AWS CloudFormation `wait` perintah, lihat di *Referensi AWS CLI Perintah*.
**AWS CodeDeploy**
Contoh perintah berikut berhenti sampai *d-A1B2C3111* penerapan selesai dengan sukses.
```
$ aws deploy wait deployment-successful --deployment-id d-A1B2C3111
```
Untuk informasi selengkapnya tentang AWS CodeDeploy `wait` perintah, lihat di *Referensi AWS CLI Perintah*.
# Menentukan nilai parameter dalam AWS CLI
Banyak parameter yang digunakan dalam AWS Command Line Interface (AWS CLI) adalah string sederhana atau nilai numerik, seperti nama kunci-pasangan `my-key-pair` dalam contoh perintah berikut`aws ec2 create-key-pair`.
```
$ aws ec2 create-key-pair --key-name my-key-pair
```
Pemformatan untuk perintah dapat bervariasi antar terminal. Misalnya, sebagian besar terminal peka huruf besar/kecil tetapi Powershell tidak peka huruf besar/kecil. Ini berarti dua contoh perintah berikut akan menghasilkan hasil yang berbeda untuk terminal peka huruf besar/kecil saat mereka melihat `MyFile*.txt` dan `myfile*.txt` sebagai parameter **yang berbeda**.
Namun, PowerShell akan memproses permintaan ini sama seperti yang terlihat `MyFile*.txt` dan `myfile*.txt` sebagai parameter yang **sama**. Contoh perintah berikut menunjukkan paramater ini menggunakan perintah: `aws s3 cp`
```
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "MyFile*.txt"
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "myfile*.txt"
```
*Untuk informasi selengkapnya tentang PowerShell case insensitivy, lihat [About\$1case-sensitivity](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_case-sensitivity) dalam dokumentasi. PowerShell*
Terkadang Anda perlu menggunakan tanda kutip atau literal di sekitar string yang menyertakan karakter khusus atau spasi. Aturan seputar pemformatan ini juga dapat bervariasi antar terminal. Untuk informasi selengkapnya tentang menggunakan tanda kutip di sekitar parameter kompleks, lihat[Menggunakan tanda kutip dan literal dengan string di AWS CLI](cli-usage-parameters-quoting-strings.md).
Topik-topik ini mencakup aturan pemformatan terminal yang paling umum. Jika Anda mengalami masalah dengan terminal mengenali nilai parameter Anda, pastikan untuk meninjau topik di bagian ini dan juga untuk memeriksa dokumentasi terminal Anda untuk aturan sintaks spesifik mereka.
**Topics**
+ [Jenis parameter umum di AWS CLI](cli-usage-parameters-types.md)
+ [Menggunakan tanda kutip dan literal dengan string di AWS CLI](cli-usage-parameters-quoting-strings.md)
+ [Memuat parameter dari file di AWS CLI](cli-usage-parameters-file.md)
+ [AWS CLI kerangka dan file input di AWS CLI](cli-usage-skeleton.md)
+ [Menggunakan sintaks singkatan di AWS CLI](cli-usage-shorthand.md)
# Jenis parameter umum di AWS CLI
Bagian ini menjelaskan beberapa jenis parameter umum dan format khas yang diperlukan.
Jika Anda mengalami masalah dalam memformat parameter untuk perintah tertentu, periksa bantuan dengan memasukkan **help** setelah nama perintah. Bantuan untuk setiap subperintah mencakup nama dan deskripsi opsi. Jenis parameter opsi tercantum dalam tanda kurung. Untuk informasi selengkapnya tentang melihat bantuan, lihat[Mengakses bantuan dan sumber daya untuk AWS CLI](cli-usage-help.md).
**Topics**
+ [String](#parameter-type-string)
+ [Stempel waktu](#parameter-type-timestamp)
+ [Daftar](#parameter-type-list)
+ [Boolean](#parameter-type-boolean)
+ [Bilangan Bulat](#parameter-type-integer)
+ [Biner/gumpalan (objek besar biner) dan gumpalan streaming](#parameter-type-blobs)
+ [Peta](#parameter-type-map)
+ [Dokumen](#parameter-type-document)
## String
Parameter string dapat berisi karakter alfanumerik, simbol, dan spasi putih dari set karakter [ASCII](https://wikipedia.org/wiki/ASCII). String yang berisi spasi putih harus dikelilingi oleh tanda kutip. Kami menyarankan Anda untuk tidak menggunakan simbol atau spasi putih selain karakter spasi standar dan untuk mematuhi [aturan kutipan](cli-usage-parameters-quoting-strings.md) terminal Anda untuk mencegah hasil yang tidak terduga.
Beberapa parameter string dapat menerima data biner dari file. Lihat [File biner](cli-usage-parameters-file.md#cli-usage-parameters-file-binary) sebagai contoh.
## Stempel waktu
Stempel waktu diformat sesuai dengan [standar ISO](https://www.iso.org/iso-8601-date-and-time-format.html) 8601. Ini sering disebut sebagai parameter "`DateTime`" atau `Date` "”.
```
$ aws ec2 describe-spot-price-history --start-time 2014-10-13T19:00:00Z
```
Format yang dapat diterima meliputi:
+ *YYYY*- *MM* - *DD* T*hh*:*mm*: *ss.sss**TZD (UTC)*, misalnya, 2014-10-01T 20:30:00.000 Z
+ *YYYY*- *MM* - *DD* T*hh*:*mm*: *ss.sss**TZD (with offset)*, misalnya, 2014-10-01T 12:30:00.000-08:00
+ *YYYY*- *MM* -*DD*, misalnya, 2014-10-01
+ Waktu Unix dalam hitungan detik, misalnya, 1412195400. Ini kadang-kadang disebut sebagai [waktu Unix Epoch](https://wikipedia.org/wiki/Unix_time) dan mewakili jumlah detik sejak tengah malam, 1 Januari 1970 UTC.
Secara default, AWS CLI versi 2 menerjemahkan semua DateTime nilai ***respons*** ke format ISO 8601.
Anda dapat mengatur format stempel waktu dengan menggunakan pengaturan `cli\$1timestamp\$1format` file.
## Daftar
Satu atau lebih string dipisahkan oleh spasi. Jika salah satu item string berisi spasi, Anda harus meletakkan tanda kutip di sekitar item itu. Amati [aturan kutipan](cli-usage-parameters-quoting-strings.md) terminal Anda untuk mencegah hasil yang tidak terduga.
```
$ aws ec2 describe-spot-price-history --instance-types m1.xlarge m1.medium
```
## Boolean
Bendera biner yang mengaktifkan atau menonaktifkan opsi. Misalnya, `ec2 describe-spot-price-history` memiliki `--dry-run` parameter Boolean yang, ketika ditentukan, memvalidasi kueri dengan layanan tanpa benar-benar menjalankan kueri.
```
$ aws ec2 describe-spot-price-history --dry-run
```
Output menunjukkan apakah perintah itu terbentuk dengan baik. Perintah ini juga menyertakan `--no-dry-run` versi parameter yang dapat Anda gunakan untuk secara eksplisit menunjukkan bahwa perintah harus dijalankan secara normal. Menyertakannya tidak perlu karena ini adalah perilaku default.
## Bilangan Bulat
Nomor bulat yang tidak ditandatangani.
```
$ aws ec2 describe-spot-price-history --max-items 5
```
## Biner/gumpalan (objek besar biner) dan gumpalan streaming
Dalam AWS CLI, Anda dapat melewatkan nilai biner sebagai string langsung pada baris perintah. Ada dua jenis gumpalan:
+ [Gumpalan](#parameter-type-blob)
+ [Gumpalan streaming](#parameter-type-streaming-blob)
### blob
Untuk meneruskan nilai ke parameter dengan tipe`blob`, Anda harus menentukan jalur ke file lokal yang berisi data biner menggunakan `fileb://` awalan. File yang direferensikan menggunakan `fileb://` awalan selalu diperlakukan sebagai biner mentah yang tidak dikodekan. Jalur yang ditentukan ditafsirkan sebagai relatif terhadap direktori kerja saat ini. Misalnya, `--plaintext` parameter untuk `aws kms encrypt` adalah gumpalan.
```
$ aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob | base64 \
--decode > ExampleEncryptedFile
```
**catatan**
Untuk kompatibilitas mundur, Anda dapat menggunakan `file://` awalan. Ada dua format yang digunakan berdasarkan pengaturan file `cli\$1binary\$1format` atau opsi baris `--cli-binary-format` perintah:
Default untuk AWS CLI versi 2. Jika nilai pengaturan adalah`base64`, file yang direferensikan menggunakan `file://` awalan diperlakukan sebagai teks berenkode base64.
Default untuk AWS CLI versi 1. Jika nilai pengaturan adalah`raw-in-base64-out`, file yang direferensikan menggunakan `file://` awalan dibaca sebagai teks dan kemudian AWS CLI upaya untuk menyandikannya ke biner.
Untuk informasi selengkapnya, lihat opsi pengaturan file `cli\$1binary\$1format` atau baris `--cli-binary-format` perintah.
### Gumpalan streaming
Gumpalan streaming seperti `aws cloudsearchdomain upload-documents` tidak menggunakan awalan. Sebagai gantinya, parameter blob streaming diformat menggunakan jalur file langsung. Contoh berikut menggunakan path file langsung `document-batch.json` untuk `aws cloudsearchdomain upload-documents` perintah:
```
$ aws cloudsearchdomain upload-documents \
--endpoint-url https://doc-my-domain.us-west-1.cloudsearch.amazonaws.com \
--content-type application/json \
--documents document-batch.json
```
## Peta
[Satu set pasangan kunci-nilai ditentukan dalam JSON atau dengan menggunakan sintaks singkatan CLI.](cli-usage-shorthand.md) Contoh JSON berikut membaca item dari tabel Amazon DynamoDB bernama *my-table* dengan parameter peta,. `--key` Parameter menentukan kunci utama bernama *id* dengan nilai angka *1* dalam struktur JSON bersarang.
Untuk penggunaan JSON yang lebih maju di baris perintah, pertimbangkan untuk menggunakan prosesor JSON baris perintah, seperti`jq`, untuk membuat string JSON. Untuk informasi lebih lanjut tentang`jq`, lihat [repositori jq](http://stedolan.github.io/jq/) di. *GitHub*
```
$ aws dynamodb get-item --table-name my-table --key '{"id": {"N":"1"}}'
{
"Item": {
"name": {
"S": "John"
},
"id": {
"N": "1"
}
}
}
```
## Dokumen
**catatan**
[Sintaks singkatan](cli-usage-shorthand.md) tidak kompatibel dengan jenis dokumen.
Jenis dokumen digunakan untuk mengirim data tanpa perlu menanamkan JSON di dalam string. Jenis dokumen memungkinkan layanan menyediakan skema arbitrer bagi Anda untuk menggunakan tipe data yang lebih fleksibel.
Ini memungkinkan untuk mengirim data JSON tanpa perlu melarikan diri dari nilai. Misalnya, alih-alih menggunakan input JSON yang lolos berikut:
```
{"document": "{\"key\":true}"}
```
Anda dapat menggunakan jenis dokumen berikut:
```
{"document": {"key": true}}
```
### Nilai yang valid untuk jenis dokumen
Karena sifat fleksibel dari jenis dokumen, ada beberapa jenis nilai yang valid. Nilai-nilai yang valid meliputi:
**String**
```
--option '"value"'
```
**Number**
```
--option 123
--option 123.456
```
**Boolean**
```
--option true
```
**Nol**
```
--option null
```
**Susunan**
```
--option '["value1", "value2", "value3"]'
--option '["value", 1, true, null, ["key1", 2.34], {"key2": "value2"}]'
```
**Objek**
```
--option '{"key": "value"}'
--option '{"key1": "value1", "key2": 123, "key3": true, "key4": null, "key5": ["value3", "value4"], "key6": {"value5": "value6"}'
```
# Menggunakan tanda kutip dan literal dengan string di AWS CLI
Ada terutama dua cara tanda kutip tunggal dan ganda digunakan dalam AWS CLI.
+ [Menggunakan tanda kutip di sekitar string yang berisi spasi putih](#cli-usage-parameters-quoting-strings-around)
+ [Menggunakan tanda kutip di dalam string](#cli-usage-parameters-quoting-strings-containing)
## Menggunakan tanda kutip di sekitar string yang berisi spasi putih
Nama parameter dan nilainya dipisahkan oleh spasi pada baris perintah. Jika nilai string berisi spasi tertanam, maka Anda harus mengelilingi seluruh string dengan tanda kutip untuk AWS CLI mencegah salah menafsirkan ruang sebagai pembagi antara nilai dan nama parameter berikutnya. Jenis tanda kutip yang Anda gunakan tergantung pada sistem operasi yang Anda gunakan. AWS CLI
------
#### [ Linux and macOS ]
Gunakan tanda kutip tunggal `' '`
```
$ aws ec2 create-key-pair --key-name 'my key pair'
```
Untuk informasi selengkapnya tentang penggunaan tanda kutip, lihat dokumentasi pengguna untuk shell pilihan Anda.
------
#### [ PowerShell ]
**Kutipan tunggal (disarankan)**
Tanda kutip tunggal `' '` disebut `verbatim` string. String diteruskan ke perintah persis seperti yang Anda ketikkan, yang berarti PowerShell variabel tidak akan melewatinya.
```
PS C:\> aws ec2 create-key-pair --key-name 'my key pair'
```
**Kutipan ganda**
Tanda kutip ganda `" "` disebut `expandable` string. Variabel dapat dilewatkan dalam string yang dapat diperluas.
```
PS C:\> aws ec2 create-key-pair --key-name "my key pair"
```
Untuk informasi selengkapnya tentang menggunakan tanda kutip, lihat [Tentang Aturan Mengutip](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) di *Microsoft PowerShell Docs*.
------
#### [ Windows command prompt ]
Gunakan tanda `" "` kutip ganda.
```
C:\> aws ec2 create-key-pair --key-name "my key pair"
```
------
Secara opsional, Anda dapat memisahkan nama parameter dari nilai dengan tanda sama dengan `=` bukan spasi. Ini biasanya diperlukan hanya jika nilai parameter dimulai dengan tanda hubung.
```
$ aws ec2 delete-key-pair --key-name=-mykey
```
## Menggunakan tanda kutip di dalam string
String mungkin berisi tanda kutip, dan shell Anda mungkin memerlukan kutipan keluar agar berfungsi dengan baik. Salah satu jenis nilai parameter umum adalah string JSON. Ini kompleks karena mencakup spasi dan tanda kutip ganda `" "` di sekitar setiap nama elemen dan nilai dalam struktur JSON. Cara memasukkan parameter yang berformat JSON pada baris perintah berbeda-beda tergantung sistem operasi Anda.
Untuk penggunaan JSON yang lebih maju di baris perintah, pertimbangkan untuk menggunakan prosesor JSON baris perintah, seperti`jq`, untuk membuat string JSON. Untuk informasi lebih lanjut tentang`jq`, lihat [repositori jq](http://stedolan.github.io/jq/) di. *GitHub*
------
#### [ Linux and macOS ]
Untuk Linux dan macOS untuk menafsirkan string secara harfiah menggunakan tanda kutip tunggal `' '` untuk melampirkan struktur data JSON, seperti pada contoh berikut. Anda tidak perlu melepaskan tanda kutip ganda yang disematkan dalam string JSON, karena mereka diperlakukan secara harfiah. Karena JSON terlampir dalam tanda kutip tunggal, setiap tanda kutip tunggal dalam string harus diloloskan, ini biasanya dilakukan dengan menggunakan garis miring terbalik sebelum kutipan tunggal. `\'`
```
$ aws ec2 run-instances \
--image-id ami-12345678 \
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
Untuk informasi selengkapnya tentang penggunaan tanda kutip, lihat dokumentasi pengguna untuk shell pilihan Anda.
------
#### [ PowerShell ]
Gunakan tanda kutip tunggal `' '` atau tanda kutip ganda. `" "`
**Kutipan tunggal (disarankan)**
Tanda kutip tunggal `' '` disebut `verbatim` string. String diteruskan ke perintah persis seperti yang Anda ketikkan, yang berarti PowerShell variabel tidak akan melewatinya.
Karena struktur data JSON menyertakan tanda kutip ganda, kami menyarankan tanda kutip **tunggal** `' '` untuk melampirkannya. Jika Anda menggunakan tanda kutip **tunggal**, Anda tidak perlu melepaskan tanda kutip **ganda** yang disematkan dalam string JSON. Namun, Anda harus keluar dari setiap tanda kutip **tunggal** dengan backtick ``` dalam struktur JSON.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
**Kutipan ganda**
Tanda kutip ganda `" "` disebut `expandable` string. Variabel dapat dilewatkan dalam string yang dapat diperluas.
Jika Anda menggunakan tanda kutip **ganda**, Anda tidak perlu melepaskan tanda kutip **tunggal** yang disematkan dalam string JSON. Namun, Anda harus keluar dari setiap tanda kutip **ganda** dengan backtick ``` dalam struktur JSON, seperti contoh berikut.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings "[{`"DeviceName`":`"/dev/sdb`",`"Ebs`":{`"VolumeSize`":20,`"DeleteOnTermination`":false,`"VolumeType`":`"standard`"}}]"
```
Untuk informasi selengkapnya tentang menggunakan tanda kutip, lihat [Tentang Aturan Mengutip](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) di *Microsoft PowerShell Docs*.
**Awas**
Sebelum PowerShell mengirim perintah ke AWS CLI, itu menentukan apakah perintah Anda ditafsirkan menggunakan aturan tipikal PowerShell atau `CommandLineToArgvW` kutipan. Saat PowerShell proses menggunakan`CommandLineToArgvW`, Anda harus melarikan diri dari karakter dengan garis miring terbalik`\`.
*Untuk informasi lebih lanjut tentang `CommandLineToArgvW` in PowerShell, lihat [Ada apa dengan perlakuan aneh tanda kutip dan garis miring terbalik oleh CommandLineToArgv W](https://devblogs.microsoft.com/oldnewthing/20100917-00/?p=12833) di *Microsoft DevBlogs*, [Semua orang mengutip argumen baris perintah dengan cara yang salah di](https://docs.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way) *Blog Microsoft Docs*, dan fungsi [CommandLineToArgvW di](https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw#remarks) Microsoft Docs.*
**Kutipan tunggal**
Tanda kutip tunggal `' '` disebut `verbatim` string. String diteruskan ke perintah persis seperti yang Anda ketikkan, yang berarti PowerShell variabel tidak akan melewatinya. Melarikan diri dari karakter dengan garis miring terbalik`\`.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings '[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]'
```
**Kutipan ganda**
Tanda kutip ganda `" "` disebut `expandable` string. Variabel dapat dilewatkan dalam `expandable` string. Untuk string kutip ganda Anda harus melarikan diri dua kali menggunakan *`\$1* untuk setiap kutipan alih-alih hanya menggunakan backtick. Backtick lolos dari garis miring terbalik, dan kemudian garis miring terbalik digunakan sebagai karakter pelarian untuk proses tersebut. `CommandLineToArgvW`
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings "[{`\"DeviceName`\":`\"/dev/sdb`\",`\"Ebs`\":{`\"VolumeSize`\":20,`\"DeleteOnTermination`\":false,`\"VolumeType`\":`\"standard`\"}}]"
```
**Gumpalan (disarankan)**
Untuk melewati aturan PowerShell kutipan untuk input data JSON, gunakan Blobs untuk meneruskan data JSON Anda langsung ke file. AWS CLI Untuk informasi lebih lanjut tentang Blobs, lihat[blob](cli-usage-parameters-types.md#parameter-type-blob).
------
#### [ Windows command prompt ]
Prompt perintah Windows memerlukan tanda kutip ganda `" "` untuk melampirkan struktur data JSON. Juga, untuk mencegah prosesor perintah salah menafsirkan tanda kutip ganda yang disematkan di JSON, Anda juga harus melarikan diri (mendahului dengan `\` karakter garis miring terbalik) setiap tanda kutip ganda `"` dalam struktur data JSON itu sendiri, seperti pada contoh berikut.
```
C:\> aws ec2 run-instances ^
--image-id ami-12345678 ^
--block-device-mappings "[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]"
```
Hanya tanda kutip ganda terluar yang tidak lolos.
------
# Memuat parameter dari file di AWS CLI
Beberapa parameter mengharapkan nama file sebagai argumen, dari mana AWS CLI memuat data. Parameter lain memungkinkan Anda untuk menentukan nilai parameter sebagai teks yang diketik pada baris perintah atau membaca dari file. Apakah file diperlukan atau opsional, Anda harus menyandikan file dengan benar sehingga AWS CLI dapat memahaminya. Pengkodean file harus sesuai dengan lokal default sistem pembacaan. Anda dapat menentukan ini dengan menggunakan metode Python`locale.getpreferredencoding()`.
Metode ini untuk memuat file untuk satu parameter. Untuk informasi tentang memuat beberapa parameter dengan satu file, lihat[AWS CLI kerangka dan file input di AWS CLI](cli-usage-skeleton.md).
**catatan**
Secara default, Windows PowerShell mengeluarkan teks sebagai UTF-16, yang bertentangan dengan pengkodean UTF-8 yang digunakan oleh file JSON dan banyak sistem Linux. Kami menyarankan Anda menggunakan `-Encoding ascii` dengan PowerShell `Out-File` perintah Anda untuk memastikan AWS CLI dapat membaca file yang dihasilkan.
**Topics**
+ [Cara memuat parameter dari file](#cli-usage-parameters-file-how)
+ [File biner](#cli-usage-parameters-file-binary)
+ [Memuat file sebagai nilai sintaks singkatan](#cli-usage-parameters-file-shorthand)
## Cara memuat parameter dari file
Terkadang lebih mudah untuk memuat nilai parameter dari file alih-alih mencoba mengetikkan semuanya sebagai nilai parameter baris perintah, seperti ketika parameternya adalah string JSON yang kompleks. Untuk menentukan file yang berisi nilai, tentukan URL file dalam format berikut.
```
file://complete/path/to/file
```
+ Dua karakter garis miring '/' pertama adalah bagian dari spesifikasi. Jika jalur yang diperlukan dimulai dengan '/', hasilnya adalah tiga karakter garis miring:`file:///folder/file`.
+ URL menyediakan path ke file yang berisi konten parameter yang sebenarnya.
+ Saat menggunakan file dengan spasi atau karakter khusus, ikuti [aturan mengutip dan melarikan diri untuk terminal](cli-usage-parameters-quoting-strings.md) Anda.
Jalur file dalam contoh berikut ditafsirkan relatif terhadap direktori kerja saat ini.
------
#### [ Linux or macOS ]
```
// Read from a file in the current directory
$ aws ec2 describe-instances --filters file://filter.json
// Read from a file in /tmp
$ aws ec2 describe-instances --filters file:///tmp/filter.json
// Read from a file with a filename with whitespaces
$ aws ec2 describe-instances --filters 'file://filter content.json'
```
------
#### [ Windows command prompt ]
```
// Read from a file in C:\temp
C:\> aws ec2 describe-instances --filters file://C:\temp\filter.json
// Read from a file with a filename with whitespaces
C:\> aws ec2 describe-instances --filters "file://C:\temp\filter content.json"
```
------
Opsi `file://` awalan mendukung ekspansi bergaya Unix, termasuk "`~/`“," “, dan"”`./`. `../` Pada Windows, ekspresi `~/` "" meluas ke direktori pengguna Anda, disimpan dalam variabel `%USERPROFILE%` lingkungan. Misalnya, pada Windows 10 Anda biasanya memiliki direktori pengguna di bawah`%USERPROFILE%`.
Anda masih harus melarikan diri dari dokumen JSON yang disematkan sebagai nilai dokumen JSON lain.
```
$ aws sqs create-queue --queue-name my-queue --attributes file://attributes.json
```
**attributes.json**
```
{
"RedrivePolicy": "{\"deadLetterTargetArn\":\"arn:aws:sqs:us-west-2:0123456789012:deadletter\", \"maxReceiveCount\":\"5\"}"
}
```
## File biner
Untuk perintah yang mengambil data biner sebagai parameter, tentukan bahwa data tersebut adalah konten biner dengan menggunakan `fileb://` awalan. Perintah yang menerima data biner meliputi:
+ **`aws ec2 run-instances:`**`--user-data`parameter.
+ **`aws s3api put-object:`**`--sse-customer-key`parameter.
+ **`aws kms decrypt:`**`--ciphertext-blob`parameter.
Contoh berikut menghasilkan kunci AES 256-bit biner menggunakan alat baris perintah Linux, dan kemudian menyediakannya ke Amazon S3 untuk mengenkripsi sisi server file yang diunggah.
```
$ dd if=/dev/urandom bs=1 count=32 > sse.key
32+0 records in
32+0 records out
32 bytes (32 B) copied, 0.000164441 s, 195 kB/s
$ aws s3api put-object \
--bucket amzn-s3-demo-bucket \
--key test.txt \
--body test.txt \
--sse-customer-key fileb://sse.key \
--sse-customer-algorithm AES256
{
"SSECustomerKeyMD5": "iVg8oWa8sy714+FjtesrJg==",
"SSECustomerAlgorithm": "AES256",
"ETag": "\"a6118e84b76cf98bf04bbe14b6045c6c\""
}
```
Untuk contoh lain yang mereferensikan file yang berisi parameter berformat JSON, lihat. [Melampirkan kebijakan terkelola IAM ke pengguna](cli-services-iam.md#cli-services-iam-policy)
## Memuat file sebagai nilai sintaks singkatan
Bila menggunakan sintaks singkatan di mana nilai besar atau kompleks, seringkali lebih mudah untuk memuat dalam file sebagai nilai. Untuk memuat file sebagai nilai sintaks singkatan, pemformatan akan sedikit berubah. Alih-alih `key=value` Anda akan menggunakan `@=` operator alih-alih `=` operator. `@=`Menandakan AWS CLI bahwa nilai harus dibaca sebagai jalur file dan bukan string. Contoh berikut menunjukkan pasangan kunci-nilai memuat file untuk nilainya.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
Contoh berikut menunjukkan memuat file sertifikat untuk `aws rolesanywhere create-trust-anchor` perintah.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
Untuk informasi selengkapnya tentang sintaks singkatan, lihat. [Menggunakan sintaks singkatan di AWS CLI](cli-usage-shorthand.md)
# AWS CLI kerangka dan file input di AWS CLI
Sebagian besar AWS CLI perintah menerima mengimpor input parameter dari file. Template ini dapat dihasilkan menggunakan `generate-cli-skeleton` opsi dan kemudian diimpor menggunakan `--cli-input-yaml` parameter `--cli-input-json` dan.
**Topics**
+ [Tentang AWS CLI kerangka dan file input](#cli-usage-skeleton-about)
+ [Menghasilkan dan mengimpor kerangka perintah](#cli-usage-skeleton-generate)
+ [Menggabungkan file input dan parameter baris perintah](#cli-usage-skeleton-combine)
## Tentang AWS CLI kerangka dan file input
Sebagian besar perintah AWS Command Line Interface (AWS CLI) mendukung kemampuan untuk menerima input parameter dari file menggunakan `--cli-input-yaml` parameter `--cli-input-json` dan s.
Perintah yang sama menggunakan `--generate-cli-skeleton` parameter untuk menghasilkan file dalam format JSON atau YAMAL dengan semua parameter yang dapat Anda edit dan isi. Kemudian Anda dapat menjalankan perintah dengan `--cli-input-yaml` parameter `--cli-input-json` or dan arahkan ke file yang diisi.
**penting**
AWS CLI Perintah khusus, seperti [perintah](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) tidak mendukung `--cli-input-yaml` parameter `--generate-cli-skeleton` atau `--cli-input-json` dan yang dijelaskan dalam topik ini. Untuk memeriksa apakah perintah tertentu mendukung parameter ini, jalankan [`help`perintah](cli-usage-help.md#cli-usage-help-command) untuk perintah yang ingin Anda gunakan atau lihat [referensi AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/reference/index.html).
`--generate-cli-skeleton`Menghasilkan dan menampilkan template parameter yang dapat Anda sesuaikan dan gunakan sebagai input pada perintah. Template yang dihasilkan mencakup semua parameter yang didukung perintah.
`--generate-cli-skeleton`Parameter menerima salah satu nilai berikut:
+ `input`— Template yang dihasilkan mencakup semua parameter input yang diformat sebagai JSON. Ini adalah nilai default.
+ `yaml-input`— Template yang dihasilkan mencakup semua parameter input yang diformat sebagai YAMAL.
+ `output`- Template yang dihasilkan mencakup semua parameter output yang diformat sebagai JSON. Saat ini Anda tidak dapat meminta parameter keluaran sebagai YAMAL.
Karena pada dasarnya AWS CLI adalah “pembungkus” di sekitar API layanan, file kerangka mengharapkan Anda untuk mereferensikan semua parameter dengan nama parameter API yang mendasarinya. Ini mungkin berbeda dari nama AWS CLI parameter. Misalnya, AWS CLI parameter bernama `user-name` mungkin memetakan ke parameter API AWS layanan bernama `UserName` (perhatikan kapitalisasi yang diubah dan tanda hubung yang hilang). Kami menyarankan Anda menggunakan `--generate-cli-skeleton` opsi untuk menghasilkan template dengan nama parameter “benar” untuk menghindari kesalahan. Anda dapat mereferensikan Panduan Referensi API agar layanan dapat melihat nama parameter yang diharapkan. Anda dapat menghapus parameter apa pun dari templat yang tidak diperlukan dan yang tidak ingin Anda berikan nilainya.
Misalnya, jika Anda menjalankan perintah berikut, itu akan menghasilkan template parameter untuk perintah Amazon Elastic Compute Cloud (Amazon EC2). **run-instances**
------
#### [ JSON ]
Contoh berikut menunjukkan bagaimana untuk menghasilkan template diformat dalam JSON dengan menggunakan nilai default (`input`) untuk parameter. `--generate-cli-skeleton`
```
$ aws ec2 run-instances --generate-cli-skeleton
```
```
{
"DryRun": true,
"ImageId": "",
"MinCount": 0,
"MaxCount": 0,
"KeyName": "",
"SecurityGroups": [
""
],
"SecurityGroupIds": [
""
],
"UserData": "",
"InstanceType": "",
"Placement": {
"AvailabilityZone": "",
"GroupName": "",
"Tenancy": ""
},
"KernelId": "",
"RamdiskId": "",
"BlockDeviceMappings": [
{
"VirtualName": "",
"DeviceName": "",
"Ebs": {
"SnapshotId": "",
"VolumeSize": 0,
"DeleteOnTermination": true,
"VolumeType": "",
"Iops": 0,
"Encrypted": true
},
"NoDevice": ""
}
],
"Monitoring": {
"Enabled": true
},
"SubnetId": "",
"DisableApiTermination": true,
"InstanceInitiatedShutdownBehavior": "",
"PrivateIpAddress": "",
"ClientToken": "",
"AdditionalInfo": "",
"NetworkInterfaces": [
{
"NetworkInterfaceId": "",
"DeviceIndex": 0,
"SubnetId": "",
"Description": "",
"PrivateIpAddress": "",
"Groups": [
""
],
"DeleteOnTermination": true,
"PrivateIpAddresses": [
{
"PrivateIpAddress": "",
"Primary": true
}
],
"SecondaryPrivateIpAddressCount": 0,
"AssociatePublicIpAddress": true
}
],
"IamInstanceProfile": {
"Arn": "",
"Name": ""
},
"EbsOptimized": true
}
```
------
#### [ YAML ]
Contoh berikut menunjukkan cara menghasilkan template yang diformat dalam YAMAL dengan menggunakan nilai `yaml-input` untuk parameter. `--generate-cli-skeleton`
```
$ aws ec2 run-instances --generate-cli-skeleton yaml-input
```
```
BlockDeviceMappings: # The block device mapping entries.
- DeviceName: '' # The device name (for example, /dev/sdh or xvdh).
VirtualName: '' # The virtual device name (ephemeralN).
Ebs: # Parameters used to automatically set up Amazon EBS volumes when the instance is launched.
DeleteOnTermination: true # Indicates whether the EBS volume is deleted on instance termination.
Iops: 0 # The number of I/O operations per second (IOPS) that the volume supports.
SnapshotId: '' # The ID of the snapshot.
VolumeSize: 0 # The size of the volume, in GiB.
VolumeType: st1 # The volume type. Valid values are: standard, io1, gp2, sc1, st1.
Encrypted: true # Indicates whether the encryption state of an EBS volume is changed while being restored from a backing snapshot.
KmsKeyId: '' # Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed KMS key under which the EBS volume is encrypted.
NoDevice: '' # Suppresses the specified device included in the block device mapping of the AMI.
ImageId: '' # The ID of the AMI.
InstanceType: c4.4xlarge # The instance type. Valid values are: t1.micro, t2.nano, t2.micro, t2.small, t2.medium, t2.large, t2.xlarge, t2.2xlarge, t3.nano, t3.micro, t3.small, t3.medium, t3.large, t3.xlarge, t3.2xlarge, t3a.nano, t3a.micro, t3a.small, t3a.medium, t3a.large, t3a.xlarge, t3a.2xlarge, m1.small, m1.medium, m1.large, m1.xlarge, m3.medium, m3.large, m3.xlarge, m3.2xlarge, m4.large, m4.xlarge, m4.2xlarge, m4.4xlarge, m4.10xlarge, m4.16xlarge, m2.xlarge, m2.2xlarge, m2.4xlarge, cr1.8xlarge, r3.large, r3.xlarge, r3.2xlarge, r3.4xlarge, r3.8xlarge, r4.large, r4.xlarge, r4.2xlarge, r4.4xlarge, r4.8xlarge, r4.16xlarge, r5.large, r5.xlarge, r5.2xlarge, r5.4xlarge, r5.8xlarge, r5.12xlarge, r5.16xlarge, r5.24xlarge, r5.metal, r5a.large, r5a.xlarge, r5a.2xlarge, r5a.4xlarge, r5a.8xlarge, r5a.12xlarge, r5a.16xlarge, r5a.24xlarge, r5d.large, r5d.xlarge, r5d.2xlarge, r5d.4xlarge, r5d.8xlarge, r5d.12xlarge, r5d.16xlarge, r5d.24xlarge, r5d.metal, r5ad.large, r5ad.xlarge, r5ad.2xlarge, r5ad.4xlarge, r5ad.8xlarge, r5ad.12xlarge, r5ad.16xlarge, r5ad.24xlarge, x1.16xlarge, x1.32xlarge, x1e.xlarge, x1e.2xlarge, x1e.4xlarge, x1e.8xlarge, x1e.16xlarge, x1e.32xlarge, i2.xlarge, i2.2xlarge, i2.4xlarge, i2.8xlarge, i3.large, i3.xlarge, i3.2xlarge, i3.4xlarge, i3.8xlarge, i3.16xlarge, i3.metal, i3en.large, i3en.xlarge, i3en.2xlarge, i3en.3xlarge, i3en.6xlarge, i3en.12xlarge, i3en.24xlarge, i3en.metal, hi1.4xlarge, hs1.8xlarge, c1.medium, c1.xlarge, c3.large, c3.xlarge, c3.2xlarge, c3.4xlarge, c3.8xlarge, c4.large, c4.xlarge, c4.2xlarge, c4.4xlarge, c4.8xlarge, c5.large, c5.xlarge, c5.2xlarge, c5.4xlarge, c5.9xlarge, c5.12xlarge, c5.18xlarge, c5.24xlarge, c5.metal, c5d.large, c5d.xlarge, c5d.2xlarge, c5d.4xlarge, c5d.9xlarge, c5d.18xlarge, c5n.large, c5n.xlarge, c5n.2xlarge, c5n.4xlarge, c5n.9xlarge, c5n.18xlarge, cc1.4xlarge, cc2.8xlarge, g2.2xlarge, g2.8xlarge, g3.4xlarge, g3.8xlarge, g3.16xlarge, g3s.xlarge, g4dn.xlarge, g4dn.2xlarge, g4dn.4xlarge, g4dn.8xlarge, g4dn.12xlarge, g4dn.16xlarge, cg1.4xlarge, p2.xlarge, p2.8xlarge, p2.16xlarge, p3.2xlarge, p3.8xlarge, p3.16xlarge, p3dn.24xlarge, d2.xlarge, d2.2xlarge, d2.4xlarge, d2.8xlarge, f1.2xlarge, f1.4xlarge, f1.16xlarge, m5.large, m5.xlarge, m5.2xlarge, m5.4xlarge, m5.8xlarge, m5.12xlarge, m5.16xlarge, m5.24xlarge, m5.metal, m5a.large, m5a.xlarge, m5a.2xlarge, m5a.4xlarge, m5a.8xlarge, m5a.12xlarge, m5a.16xlarge, m5a.24xlarge, m5d.large, m5d.xlarge, m5d.2xlarge, m5d.4xlarge, m5d.8xlarge, m5d.12xlarge, m5d.16xlarge, m5d.24xlarge, m5d.metal, m5ad.large, m5ad.xlarge, m5ad.2xlarge, m5ad.4xlarge, m5ad.8xlarge, m5ad.12xlarge, m5ad.16xlarge, m5ad.24xlarge, h1.2xlarge, h1.4xlarge, h1.8xlarge, h1.16xlarge, z1d.large, z1d.xlarge, z1d.2xlarge, z1d.3xlarge, z1d.6xlarge, z1d.12xlarge, z1d.metal, u-6tb1.metal, u-9tb1.metal, u-12tb1.metal, u-18tb1.metal, u-24tb1.metal, a1.medium, a1.large, a1.xlarge, a1.2xlarge, a1.4xlarge, a1.metal, m5dn.large, m5dn.xlarge, m5dn.2xlarge, m5dn.4xlarge, m5dn.8xlarge, m5dn.12xlarge, m5dn.16xlarge, m5dn.24xlarge, m5n.large, m5n.xlarge, m5n.2xlarge, m5n.4xlarge, m5n.8xlarge, m5n.12xlarge, m5n.16xlarge, m5n.24xlarge, r5dn.large, r5dn.xlarge, r5dn.2xlarge, r5dn.4xlarge, r5dn.8xlarge, r5dn.12xlarge, r5dn.16xlarge, r5dn.24xlarge, r5n.large, r5n.xlarge, r5n.2xlarge, r5n.4xlarge, r5n.8xlarge, r5n.12xlarge, r5n.16xlarge, r5n.24xlarge.
Ipv6AddressCount: 0 # [EC2-VPC] The number of IPv6 addresses to associate with the primary network interface.
Ipv6Addresses: # [EC2-VPC] The IPv6 addresses from the range of the subnet to associate with the primary network interface.
- Ipv6Address: '' # The IPv6 address.
KernelId: '' # The ID of the kernel.
KeyName: '' # The name of the key pair.
MaxCount: 0 # [REQUIRED] The maximum number of instances to launch.
MinCount: 0 # [REQUIRED] The minimum number of instances to launch.
Monitoring: # Specifies whether detailed monitoring is enabled for the instance.
Enabled: true # [REQUIRED] Indicates whether detailed monitoring is enabled.
Placement: # The placement for the instance.
AvailabilityZone: '' # The Availability Zone of the instance.
Affinity: '' # The affinity setting for the instance on the Dedicated Host.
GroupName: '' # The name of the placement group the instance is in.
PartitionNumber: 0 # The number of the partition the instance is in.
HostId: '' # The ID of the Dedicated Host on which the instance resides.
Tenancy: dedicated # The tenancy of the instance (if the instance is running in a VPC). Valid values are: default, dedicated, host.
SpreadDomain: '' # Reserved for future use.
RamdiskId: '' # The ID of the RAM disk to select.
SecurityGroupIds: # The IDs of the security groups.
- ''
SecurityGroups: # [default VPC] The names of the security groups.
- ''
SubnetId: '' # [EC2-VPC] The ID of the subnet to launch the instance into.
UserData: '' # The user data to make available to the instance.
AdditionalInfo: '' # Reserved.
ClientToken: '' # Unique, case-sensitive identifier you provide to ensure the idempotency of the request.
DisableApiTermination: true # If you set this parameter to true, you can't terminate the instance using the Amazon EC2 console, CLI, or API; otherwise, you can.
DryRun: true # Checks whether you have the required permissions for the action, without actually making the request, and provides an error response.
EbsOptimized: true # Indicates whether the instance is optimized for Amazon EBS I/O.
IamInstanceProfile: # The IAM instance profile.
Arn: '' # The Amazon Resource Name (ARN) of the instance profile.
Name: '' # The name of the instance profile.
InstanceInitiatedShutdownBehavior: stop # Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown). Valid values are: stop, terminate.
NetworkInterfaces: # The network interfaces to associate with the instance.
- AssociatePublicIpAddress: true # Indicates whether to assign a public IPv4 address to an instance you launch in a VPC.
DeleteOnTermination: true # If set to true, the interface is deleted when the instance is terminated.
Description: '' # The description of the network interface.
DeviceIndex: 0 # The position of the network interface in the attachment order.
Groups: # The IDs of the security groups for the network interface.
- ''
Ipv6AddressCount: 0 # A number of IPv6 addresses to assign to the network interface.
Ipv6Addresses: # One or more IPv6 addresses to assign to the network interface.
- Ipv6Address: '' # The IPv6 address.
NetworkInterfaceId: '' # The ID of the network interface.
PrivateIpAddress: '' # The private IPv4 address of the network interface.
PrivateIpAddresses: # One or more private IPv4 addresses to assign to the network interface.
- Primary: true # Indicates whether the private IPv4 address is the primary private IPv4 address.
PrivateIpAddress: '' # The private IPv4 addresses.
SecondaryPrivateIpAddressCount: 0 # The number of secondary private IPv4 addresses.
SubnetId: '' # The ID of the subnet associated with the network interface.
InterfaceType: '' # The type of network interface.
PrivateIpAddress: '' # [EC2-VPC] The primary IPv4 address.
ElasticGpuSpecification: # An elastic GPU to associate with the instance.
- Type: '' # [REQUIRED] The type of Elastic Graphics accelerator.
ElasticInferenceAccelerators: # An elastic inference accelerator to associate with the instance.
- Type: '' # [REQUIRED] The type of elastic inference accelerator.
TagSpecifications: # The tags to apply to the resources during launch.
- ResourceType: network-interface # The type of resource to tag. Valid values are: client-vpn-endpoint, customer-gateway, dedicated-host, dhcp-options, elastic-ip, fleet, fpga-image, host-reservation, image, instance, internet-gateway, launch-template, natgateway, network-acl, network-interface, reserved-instances, route-table, security-group, snapshot, spot-instances-request, subnet, traffic-mirror-filter, traffic-mirror-session, traffic-mirror-target, transit-gateway, transit-gateway-attachment, transit-gateway-route-table, volume, vpc, vpc-peering-connection, vpn-connection, vpn-gateway.
Tags: # The tags to apply to the resource.
- Key: '' # The key of the tag.
Value: '' # The value of the tag.
LaunchTemplate: # The launch template to use to launch the instances.
LaunchTemplateId: '' # The ID of the launch template.
LaunchTemplateName: '' # The name of the launch template.
Version: '' # The version number of the launch template.
InstanceMarketOptions: # The market (purchasing) option for the instances.
MarketType: spot # The market type. Valid values are: spot.
SpotOptions: # The options for Spot Instances.
MaxPrice: '' # The maximum hourly price you're willing to pay for the Spot Instances.
SpotInstanceType: one-time # The Spot Instance request type. Valid values are: one-time, persistent.
BlockDurationMinutes: 0 # The required duration for the Spot Instances (also known as Spot blocks), in minutes.
ValidUntil: 1970-01-01 00:00:00 # The end date of the request.
InstanceInterruptionBehavior: terminate # The behavior when a Spot Instance is interrupted. Valid values are: hibernate, stop, terminate.
CreditSpecification: # The credit option for CPU usage of the T2 or T3 instance.
CpuCredits: '' # [REQUIRED] The credit option for CPU usage of a T2 or T3 instance.
CpuOptions: # The CPU options for the instance.
CoreCount: 0 # The number of CPU cores for the instance.
ThreadsPerCore: 0 # The number of threads per CPU core.
CapacityReservationSpecification: # Information about the Capacity Reservation targeting option.
CapacityReservationPreference: none # Indicates the instance's Capacity Reservation preferences. Valid values are: open, none.
CapacityReservationTarget: # Information about the target Capacity Reservation.
CapacityReservationId: '' # The ID of the Capacity Reservation.
HibernationOptions: # Indicates whether an instance is enabled for hibernation.
Configured: true # If you set this parameter to true, your instance is enabled for hibernation.
LicenseSpecifications: # The license configurations.
- LicenseConfigurationArn: '' # The Amazon Resource Name (ARN) of the license configuration.
```
------
## Menghasilkan dan mengimpor kerangka perintah
**Untuk menghasilkan dan menggunakan file kerangka parameter**
1. Jalankan perintah dengan `--generate-cli-skeleton` parameter untuk menghasilkan JSON atau YAMAL dan arahkan output ke file untuk menyimpannya.
------
#### [ JSON ]
```
$ aws ec2 run-instances --generate-cli-skeleton input > ec2runinst.json
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --generate-cli-skeleton yaml-input > ec2runinst.yaml
```
------
1. Buka file kerangka parameter di editor teks Anda dan hapus salah satu parameter yang tidak Anda butuhkan. Misalnya, Anda dapat menghapus template ke bawah ini. Konfirmasikan file tersebut masih valid JSON atau YAML setelah Anda menghapus elemen yang tidak Anda butuhkan.
------
#### [ JSON ]
```
{
"DryRun": true,
"ImageId": "",
"KeyName": "",
"SecurityGroups": [
""
],
"InstanceType": "",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: true
ImageId: ''
KeyName: ''
SecurityGroups:
- ''
InstanceType:
Monitoring:
Enabled: true
```
------
Dalam contoh ini, kita membiarkan `DryRun` parameter disetel `true` untuk menggunakan fitur dry run Amazon EC2. Fitur ini memungkinkan Anda menguji perintah dengan aman tanpa benar-benar membuat atau memodifikasi sumber daya apa pun.
1. Isi nilai yang tersisa dengan nilai yang sesuai untuk skenario Anda. Dalam contoh ini, kami menyediakan jenis instans, nama kunci, grup keamanan, dan pengenal Amazon Machine Image (AMI) untuk digunakan. Contoh ini mengasumsikan default Wilayah AWS. AMI `ami-dfc39aef` adalah gambar Linux Amazon 64-bit yang dihosting di `us-west-2` Wilayah. Jika Anda menggunakan Wilayah yang berbeda, Anda harus [menemukan ID AMI yang benar untuk digunakan](https://aws.amazon.com/amazon-linux-ami/).
------
#### [ JSON ]
```
{
"DryRun": true,
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: true
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
1. Jalankan perintah dengan parameter lengkap dengan meneruskan file template yang sudah selesai ke `cli-input-yaml` parameter `--cli-input-json` or -- dengan menggunakan `file://` awalan. AWS CLI Menafsirkan jalur menjadi relatif terhadap direktori kerja Anda saat ini. Contoh berikut AWS CLI mencari file di direktori kerja saat ini.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
Kesalahan dry run menunjukkan bahwa JSON atau YAMAL terbentuk dengan benar dan nilai parameternya valid. Jika masalah lain dilaporkan dalam output, perbaiki dan ulangi langkah sebelumnya hingga pesan `Request would have succeeded` "" ditampilkan.
1. Sekarang Anda dapat mengatur `DryRun` parameter `false` untuk menonaktifkan dry run.
------
#### [ JSON ]
```
{
"DryRun": false,
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: false
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
1. Jalankan perintah, dan `run-instances` benar-benar meluncurkan instans Amazon EC2 dan menampilkan detail yang dihasilkan oleh peluncuran yang berhasil. Format output dikontrol oleh `--output` parameter, terpisah dari format template parameter input Anda.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --output json
```
```
{
"OwnerId": "123456789012",
"ReservationId": "r-d94a2b1",
"Groups": [],
"Instances": [
...
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --output yaml
```
```
OwnerId: '123456789012'
ReservationId: 'r-d94a2b1',
Groups":
- ''
Instances:
...
```
------
## Menggabungkan file input dan parameter baris perintah
File input dapat digunakan untuk semua parameter, atau dapat dikombinasikan dengan parameter yang ditentukan dalam file AWS CLI. Anda dapat menggunakan fitur ini untuk pengaturan yang sering Anda gunakan kembali dalam file input, sambil menjaga pengaturan individual Anda dalam perintah itu sendiri.
`aws ec2 run-instances`Contoh berikut menggabungkan penggunaan file input dan parameter. Kami menyediakan jenis instans, nama kunci, grup keamanan, pengenal Amazon Machine Image (AMI) untuk digunakan dan mengasumsikan default Wilayah AWS. AMI `ami-dfc39aef` adalah gambar Linux Amazon 64-bit yang dihosting di `us-west-2` Wilayah. Jika Anda menggunakan Wilayah yang berbeda, Anda harus [menemukan ID AMI yang benar untuk digunakan](https://aws.amazon.com/amazon-linux-ami/).
------
#### [ JSON ]
Isi file JSON:
```
{
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
Isi file YAMAL:
```
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
Contoh berikut menggunakan file input dalam kombinasi dengan `--dry-run` parameter untuk melakukan dry-run perintah untuk mengkonfirmasi apakah Anda memiliki izin yang diperlukan dan telah mengisi file dengan nilai yang valid.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --dry-run
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --dry-run
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
Contoh berikut kemudian menggunakan file input yang sama, tetapi dengan `--no-dry-run` parameter untuk melakukan perintah secara penuh.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --no-dry-run --output json
```
```
{
"OwnerId": "123456789012",
"ReservationId": "r-d94a2b1",
"Groups": [],
"Instances": [
...
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --no-dry-run --output yaml
```
```
OwnerId: '123456789012'
ReservationId: 'r-d94a2b1',
Groups":
- ''
Instances:
...
```
------
# Menggunakan sintaks singkatan di AWS CLI
The AWS Command Line Interface (AWS CLI) dapat menerima banyak parameter opsinya dalam format JSON. Namun, bisa membosankan untuk memasukkan daftar atau struktur JSON besar pada baris perintah. Untuk membuat ini lebih mudah, AWS CLI juga mendukung sintaks singkatan yang memungkinkan representasi yang lebih sederhana dari parameter opsi Anda daripada menggunakan format JSON lengkap.
**Topics**
+ [Parameter struktur dengan pasangan kunci-nilai](#shorthand-structure-parameters)
+ [Memuat file sebagai nilai sintaks singkatan](#shorthand-files)
+ [Menggunakan sintaks singkatan dengan AWS CLI](#shorthand-list-parameters)
## Parameter struktur dengan pasangan kunci-nilai
Sintaks singkatan dalam AWS CLI memudahkan pengguna untuk memasukkan parameter yang datar (struktur non-bersarang). Formatnya adalah daftar pasangan kunci-nilai yang dipisahkan koma. Pastikan untuk menggunakan aturan [kutipan](cli-usage-parameters-quoting-strings.md) dan escaping yang sesuai untuk terminal Anda karena sintaks singkatan adalah string.
------
#### [ Linux or macOS ]
```
--option key1=value1,key2=value2,key3=value3
```
Setara dengan contoh berikut, diformat dalam JSON.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
#### [ Windows ]
```
--option "key1=value1,key2=value2,key3=value3"
```
Setara dengan contoh berikut, diformat dalam JSON.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
Tidak boleh ada spasi putih di antara setiap pasangan nilai kunci yang dipisahkan koma. Berikut adalah contoh perintah Amazon `update-table` DynamoDB dengan opsi yang ditentukan `--provisioned-throughput` dalam singkatan.
```
$ aws dynamodb update-table \
--provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10 \
--table-name MyDDBTable
```
Ini setara dengan contoh berikut yang diformat dalam JSON.
```
$ aws dynamodb update-table \
--provisioned-throughput '{"ReadCapacityUnits":15,"WriteCapacityUnits":10}' \
--table-name MyDDBTable
```
## Memuat file sebagai nilai sintaks singkatan
Ketika suatu nilai besar atau kompleks, seringkali lebih mudah untuk memuat sebagai nilai. Untuk memuat file sebagai nilai sintaks singkatan, pemformatan akan sedikit berubah. Alih-alih `key=value` Anda akan menggunakan `@=` operator alih-alih `=` operator. `@=`Menandakan AWS CLI bahwa nilai harus dibaca sebagai jalur file dan bukan string. Saat memuat file dalam sintaks singkatan, aturan [pemformatan AWS CLI file yang biasa berlaku](cli-usage-parameters-file.md). Contoh berikut menunjukkan pasangan kunci-nilai memuat file untuk nilainya.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
Contoh berikut menunjukkan memuat file sertifikat untuk `aws rolesanywhere create-trust-anchor` perintah.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
## Menggunakan sintaks singkatan dengan AWS CLI
Anda dapat menentukan parameter Input dalam formulir daftar dengan dua cara: JSON atau singkatan. Sintaks AWS CLI singkatan dirancang untuk membuatnya lebih mudah untuk meneruskan daftar dengan angka, string, atau struktur non-bersarang.
Format dasar ditampilkan di sini, di mana nilai-nilai dalam daftar dipisahkan oleh satu spasi.
```
--option value1 value2 value3
```
Ini setara dengan contoh berikut, diformat dalam JSON.
```
--option '[value1,value2,value3]'
```
Seperti disebutkan sebelumnya, Anda dapat menentukan daftar angka, daftar string, atau daftar struktur non-bersarang di singkatan. Berikut ini adalah contoh `stop-instances` perintah untuk Amazon Elastic Compute Cloud (Amazon EC2), di mana parameter input (daftar string) untuk `--instance-ids` opsi ditentukan dalam singkatan.
```
$ aws ec2 stop-instances \
--instance-ids i-1486157a i-1286157c i-ec3a7e87
```
Ini setara dengan contoh berikut yang diformat dalam JSON.
```
$ aws ec2 stop-instances \
--instance-ids '["i-1486157a","i-1286157c","i-ec3a7e87"]'
```
Contoh berikut menunjukkan `create-tags` perintah Amazon EC2, yang mengambil daftar struktur non-bersarang untuk opsi tersebut. `--tags` `--resources`Pilihan menentukan ID dari contoh untuk tag.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags Key=My1stTag,Value=Value1 Key=My2ndTag,Value=Value2 Key=My3rdTag,Value=Value3
```
Ini setara dengan contoh berikut, diformat dalam JSON. Parameter JSON ditulis di atas beberapa baris untuk keterbacaan.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags '[
{"Key": "My1stTag", "Value": "Value1"},
{"Key": "My2ndTag", "Value": "Value2"},
{"Key": "My3rdTag", "Value": "Value3"}
]'
```
# Mengaktifkan dan menggunakan command prompt di AWS CLI
Anda dapat meminta perintah, parameter, dan sumber daya AWS CLI versi 2 saat menjalankan `aws` perintah.
**Topics**
+ [Cara kerjanya](#cli-usage-auto-prompt-about)
+ [Fitur prompt otomatis](#cli-usage-auto-prompt-features)
+ [Mode prompt otomatis](#cli-usage-auto-prompt-modes)
+ [Konfigurasikan prompt otomatis](#cli-usage-auto-prompt-configure)
## Cara kerjanya
Jika diaktifkan, prompt otomatis memungkinkan Anda menggunakan tombol **ENTER** untuk menyelesaikan perintah yang dimasukkan sebagian. Setelah menekan tombol **ENTER**, perintah, parameter, dan sumber daya disarankan berdasarkan apa yang terus Anda ketik. Saran mencantumkan nama perintah, parameter, atau sumber daya di sebelah kiri dan deskripsi di sebelah kanan. Untuk memilih dan menggunakan saran, gunakan tombol panah untuk menyorot baris, lalu tekan tombol **SPASI**. Setelah selesai memasukkan perintah Anda, tekan **ENTER** untuk menggunakan perintah. Contoh berikut menunjukkan seperti apa daftar yang disarankan dari prompt otomatis.
```
$ aws
> aws a
accessanalyzer Access Analyzer
acm AWS Certificate Manager
acm-pca AWS Certificate Manager Private Certificate Authority
alexaforbusiness Alexa For Business
amplify AWS Amplify
```
## Fitur prompt otomatis
Prompt otomatis berisi fitur berguna berikut:
**Panel dokumentasi**
Menyediakan dokumentasi bantuan untuk perintah saat ini. Untuk membuka dokumentasi, tekan tombol **F3**.
**Penyelesaian perintah**
Menyarankan `aws` perintah untuk digunakan. Untuk melihat daftar, masukkan sebagian perintah. Contoh berikut adalah mencari layanan yang dimulai dengan huruf itu`a`.
```
$ aws
> aws a
accessanalyzer Access Analyzer
acm AWS Certificate Manager
acm-pca AWS Certificate Manager Private Certificate Authority
alexaforbusiness Alexa For Business
amplify AWS Amplify
```
**Penyelesaian parameter**
Setelah perintah diketik, prompt otomatis mulai menyarankan parameter. Deskripsi untuk parameter termasuk jenis nilai, dan deskripsi tentang apa parameternya. Parameter yang diperlukan tercantum terlebih dahulu, dan diberi label sesuai kebutuhan. Contoh berikut menunjukkan daftar auto-prompt parameter untuk`aws dynamodb describe-table`.
```
$ aws dynamodb describe-table
> aws dynamodb describe-table
--table-name (required) [string] The name of the table to describe.
--cli-input-json [string] Reads arguments from the JSON string provided. The JSON string follows the format provide...
--cli-input-yaml [string] Reads arguments from the YAML string provided. The YAML string follows the format provide...
--generate-cli-skeleton [string] Prints a JSON skeleton to standard output without sending an API request. If provided wit...
```
**Penyelesaian sumber daya**
Prompt otomatis membuat panggilan AWS API menggunakan properti sumber daya AWS yang tersedia untuk menyarankan nilai sumber daya. Ini memungkinkan prompt otomatis untuk menyarankan kemungkinan sumber daya yang Anda miliki saat memasukkan parameter. Dalam contoh berikut, prompt otomatis mencantumkan nama tabel Anda saat mengisi `--table-name` parameter untuk `aws dynamodb describe-table` perintah.
```
$ aws dynamodb describe-table
> aws dynamodb describe-table --table-name
Table1
Table2
Table3
```
**Penyelesaian singkatan**
Untuk parameter yang menggunakan sintaks singkatan, prompt otomatis menyarankan nilai untuk digunakan. Dalam contoh berikut, prompt otomatis mencantumkan nilai sintaks singkatan untuk `--placement` parameter dalam perintah. `aws ec2 run-instances`
```
$ aws ec2 run-instances
> aws ec2 run-instances --placement
AvailabilityZone= [string] The Availability Zone of the instance. If not specified, an Availability Zone wil...
Affinity= [string] The affinity setting for the instance on the Dedicated Host. This parameter is no...
GroupName= [string] The name of the placement group the instance is in.
PartitionNumber= [integer] The number of the partition the instance is in. Valid only if the placement grou...
```
**Penyelesaian file**
Saat mengisi parameter dalam `aws` perintah, pelengkapan otomatis menyarankan nama file lokal setelah menggunakan awalan atau. `file://` `fileb://` Dalam contoh berikut, prompt otomatis menyarankan file lokal setelah masuk `--item file://` untuk `aws ec2 run-instances` perintah.
```
$ aws ec2 run-instances
> aws ec2 run-instances --item file://
item1.txt
file1.json
file2.json
```
**Penyelesaian wilayah**
Saat menggunakan parameter global`--region`, prompt otomatis mencantumkan kemungkinan Wilayah untuk dipilih. Dalam contoh berikut, prompt otomatis menyarankan Wilayah dalam urutan abjad setelah masuk `--region` untuk perintah. `aws dynamodb list-tables`
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --region
af-south-1
ap-east-1
ap-northeast-1
ap-northeast-2
```
**Penyelesaian profil**
Saat menggunakan parameter global`--profile`, prompt otomatis mencantumkan profil Anda. Dalam contoh berikut, prompt otomatis menyarankan profil Anda setelah masuk `--profile` untuk `aws dynamodb list-tables` perintah.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --profile
profile1
profile2
profile3
```
**Pencarian fuzzy**
Lengkapi perintah dan nilai yang berisi serangkaian karakter tertentu. Dalam contoh berikut, prompt otomatis menyarankan Wilayah yang berisi `eu` setelah masuk `--region eu` untuk `aws dynamodb list-tables` perintah.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --region west
eu-west-1
eu-west-2
eu-west-3
us-west-1
```
**Riwayat**
Untuk melihat dan menjalankan perintah yang sebelumnya digunakan dalam mode prompt otomatis, tekan **CTRL\$1R**. Riwayat mencantumkan perintah sebelumnya yang dapat Anda pilih dengan menggunakan tombol panah. Dalam contoh berikut, riwayat mode auto-prompt ditampilkan.
```
$ aws
> aws
dynamodb list-tables
s3 ls
```
## Mode prompt otomatis
Auto-prompt untuk AWS CLI versi 2 memiliki 2 mode yang dapat dikonfigurasi:
+ **Mode penuh:** Menggunakan prompt otomatis setiap kali Anda mencoba menjalankan `aws` perintah, apakah Anda memanggilnya secara manual menggunakan `--cli-auto-prompt` parameter atau mengaktifkannya secara permanen. Ini termasuk menekan **ENTER** setelah perintah lengkap atau perintah tidak lengkap.
+ **Mode paral:** Menggunakan prompt otomatis jika perintah tidak lengkap atau tidak dapat dijalankan karena kesalahan validasi sisi klien. Mode ini sangat berguna jika Anda memiliki skrip, runbook, atau Anda hanya ingin diminta secara otomatis untuk perintah yang tidak Anda kenal daripada diminta pada setiap perintah.
## Konfigurasikan prompt otomatis
Untuk mengkonfigurasi prompt otomatis Anda dapat menggunakan metode berikut dalam urutan prioritas:
+ **Opsi baris perintah** mengaktifkan atau menonaktifkan prompt otomatis untuk satu perintah. Gunakan `--cli-auto-prompt` untuk memanggil auto-prompt dan `--no-cli-auto-prompt` untuk menonaktifkan auto-prompt.
+ **Variabel lingkungan** menggunakan `aws\$1cli\$1auto\$1prompt` variabel.
+ **File konfigurasi bersama** menggunakan `cli\$1auto\$1prompt` pengaturan.
# Mengontrol output perintah di AWS CLI
Bagian ini menjelaskan berbagai cara untuk mengontrol output dari AWS Command Line Interface (AWS CLI). Menyesuaikan AWS CLI output di terminal Anda dapat meningkatkan keterbacaan, merampingkan otomatisasi skrip, dan memberikan navigasi yang lebih mudah melalui kumpulan data yang lebih besar.
AWS CLI Mendukung beberapa [format output](cli-usage-output-format.md), termasuk [`json`](cli-usage-output-format.md#json-output), [`text`](cli-usage-output-format.md#text-output), [`yaml`](cli-usage-output-format.md#yaml-output), [`off`](cli-usage-output-format.md#off-output), dan [`table`](cli-usage-output-format.md#table-output). Beberapa layanan memiliki [pagination](cli-usage-pagination.md) sisi server untuk data mereka dan AWS CLI menyediakan fitur sisi kliennya sendiri untuk opsi pagination tambahan.
Terakhir, AWS CLI memiliki [penyaringan sisi server dan sisi klien yang dapat Anda gunakan secara individual atau bersama-sama untuk memfilter](cli-usage-filter.md) output Anda. AWS CLI
**Topics**
+ [Output sensitif](#cli-usage-output-sensitive)
+ [Opsi keluaran sisi server vs sisi klien](#cli-usage-output-server-client)
+ [Mengatur format output di AWS CLI](cli-usage-output-format.md)
+ [Output kesalahan terstruktur di AWS CLI](cli-usage-error-format.md)
+ [Menggunakan opsi pagination di AWS CLI](cli-usage-pagination.md)
+ [Output penyaringan di AWS CLI](cli-usage-filter.md)
## Output sensitif
Beberapa operasi AWS CLI mungkin mengembalikan informasi yang dapat dianggap sensitif, termasuk informasi dari variabel lingkungan. Paparan informasi ini mungkin mewakili risiko keamanan dalam skenario tertentu; misalnya, informasi dapat dimasukkan dalam log integrasi berkelanjutan dan penyebaran berkelanjutan (CI/CD). Oleh karena itu penting bahwa Anda meninjau ketika Anda memasukkan output tersebut sebagai bagian dari log Anda, dan menekan output ketika tidak diperlukan.
Untuk informasi tambahan tentang melindungi data sensitif, lihat[Perlindungan data di AWS CLI](data-protection.md).
Pertimbangkan praktik terbaik berikut:
+ Pertimbangkan untuk mengambil rahasia Anda secara terprogram dari toko rahasia, seperti. AWS Secrets Manager
+ Tinjau konten log build Anda untuk memastikan bahwa log tersebut tidak berisi informasi sensitif. Pertimbangkan pendekatan seperti perpipaan ke `/dev/null` atau menangkap output sebagai bash atau PowerShell variabel untuk menekan output perintah.
Berikut ini adalah contoh bash untuk mengarahkan output, tetapi bukan kesalahan, ke: `/dev/null`
```
$ aws s3 ls > /dev/null
```
Untuk spesifik tentang menekan output untuk terminal Anda, lihat dokumentasi pengguna terminal yang Anda gunakan.
+ Pertimbangkan akses log Anda dan cakupan akses yang tepat untuk kasus penggunaan Anda.
## Opsi keluaran sisi server vs sisi klien
Ini AWS CLI memiliki penyaringan sisi [server dan sisi klien yang dapat Anda gunakan secara individual atau bersama-sama untuk memfilter](cli-usage-filter.md) output Anda. AWS CLI Pemfilteran sisi server diproses terlebih dahulu dan mengembalikan output Anda untuk pemfilteran sisi klien. Pemfilteran sisi server didukung oleh API layanan. Pemfilteran sisi klien didukung oleh AWS CLI klien menggunakan parameter. `--query`
Opsi keluaran **sisi server** adalah fitur yang didukung langsung oleh API. Layanan AWS Setiap data yang disaring atau paged out tidak dikirim ke klien, yang dapat mempercepat waktu respons HTTP dan meningkatkan bandwidth untuk kumpulan data yang lebih besar.
Opsi keluaran **sisi klien** adalah fitur yang dibuat oleh. AWS CLI Semua data dikirim ke klien, kemudian AWS CLI filter atau halaman konten ditampilkan. Operasi sisi klien tidak menghemat kecepatan atau bandwidth untuk kumpulan data yang lebih besar.
Ketika opsi sisi server dan sisi klien digunakan bersama-sama, operasi sisi server diselesaikan terlebih dahulu dan kemudian dikirim ke klien untuk operasi sisi klien. Ini menggunakan potensi penghematan kecepatan dan bandwidth dari opsi sisi server, sambil menggunakan AWS CLI fitur tambahan untuk mendapatkan output yang Anda inginkan.
# Mengatur format output di AWS CLI
Topik ini menjelaskan format keluaran yang berbeda untuk AWS Command Line Interface (AWS CLI). AWS CLI Mendukung format output berikut:
+ **[`json`](#json-output)**— Output diformat sebagai string [JSON](https://json.org/).
+ **[`yaml`](#yaml-output)**— Output diformat sebagai string [YAMAL.](https://yaml.org/)
+ **[`yaml-stream`](#yaml-stream-output)**— Output dialirkan dan diformat sebagai string [YAMAL](https://yaml.org/). Streaming memungkinkan penanganan tipe data besar yang lebih cepat.
+ **[`text`](#text-output)**- Output diformat sebagai beberapa baris nilai string yang dipisahkan tab. Ini dapat berguna untuk meneruskan output ke prosesor teks, seperti`grep`,`sed`, atau`awk`.
+ **[`table`](#table-output)**— Output diformat sebagai tabel menggunakan karakter \$1\$1- untuk membentuk batas sel. Ini biasanya menyajikan informasi dalam format “ramah manusia” yang jauh lebih mudah dibaca daripada yang lain, tetapi tidak berguna secara terprogram.
+ **[`off`](#off-output)**— Output menekan semua output perintah ke stdout. Ini berguna dalam skrip otomatisasi dan CI/CD saluran pipa di mana Anda hanya perlu memeriksa kode keluar perintah tanpa memproses output.
## Cara memilih format output
Seperti yang dijelaskan dalam topik [konfigurasi](cli-chap-configure.md), Anda dapat menentukan format output dalam tiga cara:
+ **Menggunakan `output` opsi dalam profil bernama dalam `config` file** - Contoh berikut menetapkan format output default ke`text`.
```
[default]
output=text
```
+ **Menggunakan variabel `AWS_DEFAULT_OUTPUT` lingkungan** - Output berikut menetapkan format `table` untuk perintah dalam sesi baris perintah ini sampai variabel diubah atau sesi berakhir. Menggunakan variabel lingkungan ini mengesampingkan nilai apa pun yang ditetapkan dalam file. `config`
```
$ export AWS_DEFAULT_OUTPUT="table"
```
+ **Menggunakan `--output` opsi pada baris perintah** - Contoh berikut menetapkan output dari hanya satu perintah ini`json`. Menggunakan opsi ini pada perintah mengesampingkan variabel lingkungan yang saat ini ditetapkan atau nilai dalam file. `config`
```
$ aws swf list-domains --registration-status REGISTERED --output json
```
**penting**
Jenis output yang Anda tentukan mengubah cara `--query` opsi beroperasi:
Jika Anda menentukan`--output text`, output diberi paginasi *sebelum* `--query` filter diterapkan, dan AWS CLI menjalankan kueri sekali pada *setiap halaman* output. Karena ini, kueri menyertakan elemen pencocokan pertama pada setiap halaman yang dapat menghasilkan output tambahan yang tidak terduga. Untuk memfilter output tambahan, Anda dapat menggunakan alat baris perintah lainnya seperti `head` atau`tail`.
Jika Anda menentukan `--output json` `--output yaml`,, atau `--output yaml-stream` output sepenuhnya diproses sebagai struktur asli tunggal sebelum `--query` filter diterapkan. AWS CLI Menjalankan kueri hanya sekali terhadap seluruh struktur, menghasilkan hasil yang difilter yang kemudian dikeluarkan.
## Format keluaran JSON
[JSON](https://json.org) adalah format output default dari file. AWS CLI Sebagian besar bahasa pemrograman dapat dengan mudah memecahkan kode string JSON menggunakan fungsi bawaan atau dengan perpustakaan yang tersedia untuk umum. Anda dapat menggabungkan output JSON dengan [opsi --query](cli-usage-filter.md) dengan cara yang ampuh untuk memfilter dan memformat output berformat AWS CLI JSON.
Untuk pemfilteran lebih lanjut yang mungkin tidak dapat Anda lakukan`--query`, Anda dapat mempertimbangkan`jq`, prosesor JSON baris perintah. Anda dapat mengunduhnya dan menemukan tutorial resminya di [http://stedolan.github.io/jq/](http://stedolan.github.io/jq/).
Berikut ini adalah contoh output JSON.
```
$ aws iam list-users --output json
```
```
{
"Users": [
{
"Path": "/",
"UserName": "Admin",
"UserId": "AIDA1111111111EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/Admin",
"CreateDate": "2014-10-16T16:03:09+00:00",
"PasswordLastUsed": "2016-06-03T18:37:29+00:00"
},
{
"Path": "/backup/",
"UserName": "backup-user",
"UserId": "AIDA2222222222EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/backup/backup-user",
"CreateDate": "2019-09-17T19:30:40+00:00"
},
{
"Path": "/",
"UserName": "cli-user",
"UserId": "AIDA3333333333EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/cli-user",
"CreateDate": "2019-09-17T19:11:39+00:00"
}
]
}
```
## Format keluaran YAMAL
[YAMG](https://yaml.org) [adalah pilihan yang baik untuk menangani output secara terprogram dengan layanan dan alat yang memancarkan atau menggunakan string berformat [YAMAL, seperti dengan dukungannya](https://yaml.org) untuk template berformat YAMG. CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-formats.html)
Untuk pemfilteran lebih lanjut yang mungkin tidak dapat Anda lakukan`--query`, Anda dapat mempertimbangkan`yq`, prosesor YAMAL baris perintah. Anda dapat mengunduh `yq` di [repositori yq](https://github.com/mikefarah/yq) di. *GitHub*
Berikut ini adalah contoh output YAMAL.
```
$ aws iam list-users --output yaml
```
```
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
## Format keluaran aliran YAMAL
`yaml-stream`Format ini memanfaatkan format [YAMAL](https://yaml.org) sambil memberikan tampilan kumpulan data besar yang lebih responsif/lebih cepat dengan mengalirkan data kepada Anda. Anda dapat mulai melihat dan menggunakan data YAMAL sebelum seluruh unduhan kueri.
Untuk pemfilteran lebih lanjut yang mungkin tidak dapat Anda lakukan`--query`, Anda dapat mempertimbangkan`yq`, prosesor YAMAL baris perintah. Anda dapat mengunduh `yq` di [repositori yq](https://github.com/mikefarah/yq) di. *GitHub*
Berikut ini adalah contoh `yaml-stream` output.
```
$ aws iam list-users --output yaml-stream
```
```
- IsTruncated: false
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
Berikut ini adalah contoh `yaml-stream` output dalam hubungannya dengan menggunakan `--page-size` parameter untuk paginasi konten YAML yang dialirkan.
```
$ aws iam list-users --output yaml-stream --page-size 2
```
```
- IsTruncated: true
Marker: ab1234cdef5ghi67jk8lmo9p/q012rs3t445uv6789w0x1y2z/345a6b78c9d00/1efgh234ij56klmno78pqrstu90vwxyx
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- IsTruncated: false
Users:
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
## Format keluaran teks
`text`Format mengatur AWS CLI output ke dalam baris yang dibatasi tab. Ini bekerja dengan baik dengan alat teks Unix tradisional seperti`grep`,`sed`, dan`awk`, dan pemrosesan teks yang dilakukan oleh PowerShell.
Format `text` output mengikuti struktur dasar yang ditunjukkan di bawah ini. Kolom diurutkan menurut abjad dengan nama kunci yang sesuai dari objek JSON yang mendasarinya.
```
IDENTIFIER sorted-column1 sorted-column2
IDENTIFIER2 sorted-column1 sorted-column2
```
Berikut ini adalah contoh `text` output. Setiap bidang adalah tab yang terpisah dari yang lain, dengan tab tambahan di mana ada bidang kosong.
```
$ aws iam list-users --output text
```
```
USERS arn:aws:iam::123456789012:user/Admin 2014-10-16T16:03:09+00:00 2016-06-03T18:37:29+00:00 / AIDA1111111111EXAMPLE Admin
USERS arn:aws:iam::123456789012:user/backup/backup-user 2019-09-17T19:30:40+00:00 /backup/ AIDA2222222222EXAMPLE backup-user
USERS arn:aws:iam::123456789012:user/cli-user 2019-09-17T19:11:39+00:00 / AIDA3333333333EXAMPLE cli-user
```
Kolom keempat adalah `PasswordLastUsed` bidang, dan kosong untuk dua entri terakhir karena pengguna tersebut tidak pernah masuk ke Konsol Manajemen AWS.
**penting**
*Kami sangat menyarankan bahwa jika Anda menentukan `text` output, Anda juga selalu menggunakan [`--query`](cli-usage-filter.md)opsi untuk memastikan perilaku yang konsisten*.
Ini karena format teks menurut abjad mengurutkan kolom keluaran dengan nama kunci objek JSON yang mendasari yang dikembalikan oleh AWS layanan, dan sumber daya serupa mungkin tidak memiliki nama kunci yang sama. Misalnya, representasi JSON dari instans Amazon EC2 berbasis Linux mungkin memiliki elemen yang tidak ada dalam representasi JSON dari instance berbasis Windows, atau sebaliknya. Selain itu, sumber daya mungkin memiliki elemen nilai kunci yang ditambahkan atau dihapus di pembaruan masa depan, mengubah urutan kolom. Di sinilah `--query` menambah fungsionalitas `text` output untuk memberi Anda kontrol penuh atas format output.
Dalam contoh berikut, perintah menentukan elemen mana yang akan ditampilkan dan *mendefinisikan urutan* kolom dengan notasi daftar. `[key1, key2, ...]` Ini memberi Anda keyakinan penuh bahwa nilai kunci yang benar selalu ditampilkan di kolom yang diharapkan. Akhirnya, perhatikan bagaimana AWS CLI output `None` sebagai nilai untuk kunci yang tidak ada.
```
$ aws iam list-users --output text --query 'Users[*].[UserName,Arn,CreateDate,PasswordLastUsed,UserId]'
```
```
Admin arn:aws:iam::123456789012:user/Admin 2014-10-16T16:03:09+00:00 2016-06-03T18:37:29+00:00 AIDA1111111111EXAMPLE
backup-user arn:aws:iam::123456789012:user/backup-user 2019-09-17T19:30:40+00:00 None AIDA2222222222EXAMPLE
cli-user arn:aws:iam::123456789012:user/cli-backup 2019-09-17T19:11:39+00:00 None AIDA3333333333EXAMPLE
```
Contoh berikut menunjukkan bagaimana Anda dapat menggunakan `grep` dan `awk` dengan `text` output dari `aws ec2 describe-instances` perintah. Perintah pertama menampilkan Availability Zone, status saat ini, dan ID instance dari setiap instance dalam `text` output. Perintah kedua memproses output yang hanya menampilkan instance IDs dari semua instance yang berjalan di `us-west-2a` Availability Zone.
```
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text
```
```
us-west-2a running i-4b41a37c
us-west-2a stopped i-a071c394
us-west-2b stopped i-97a217a0
us-west-2a running i-3045b007
us-west-2a running i-6fc67758
```
```
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text | grep us-west-2a | grep running | awk '{print $3}'
```
```
i-4b41a37c
i-3045b007
i-6fc67758
```
Contoh berikut melangkah lebih jauh dan menunjukkan tidak hanya cara memfilter output, tetapi bagaimana menggunakan output itu untuk mengotomatiskan jenis instance yang berubah untuk setiap instance yang dihentikan.
```
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[State.Name, InstanceId]' --output text |
> grep stopped |
> awk '{print $2}' |
> while read line;
> do aws ec2 modify-instance-attribute --instance-id $line --instance-type '{"Value": "m1.medium"}';
> done
```
`text`Outputnya juga bisa berguna di PowerShell. Karena kolom dalam `text` output dibatasi tab, Anda dapat dengan mudah membagi output menjadi array dengan menggunakan PowerShell pembatas. ``t` Perintah berikut menampilkan nilai kolom ketiga (`InstanceId`) jika kolom pertama (`AvailabilityZone`) cocok dengan string`us-west-2a`.
```
PS C:\>aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text |
%{if ($_.split("`t")[0] -match "us-west-2a") { $_.split("`t")[2]; } }
```
```
-4b41a37c
i-a071c394
i-3045b007
i-6fc67758
```
Perhatikan bahwa meskipun contoh sebelumnya menunjukkan cara menggunakan `--query` parameter untuk mengurai objek JSON yang mendasarinya dan mengeluarkan kolom yang diinginkan, PowerShell memiliki kemampuannya sendiri untuk menangani JSON, jika kompatibilitas lintas platform tidak menjadi perhatian. Alih-alih menangani output sebagai teks, seperti yang dibutuhkan kebanyakan shell perintah, PowerShell memungkinkan Anda menggunakan `ConvertFrom-JSON` cmdlet untuk menghasilkan objek yang terstruktur secara hierarkis. Anda kemudian dapat langsung mengakses anggota yang Anda inginkan dari objek itu.
```
(aws ec2 describe-instances --output json | ConvertFrom-Json).Reservations.Instances.InstanceId
```
**Tip**
Jika Anda mengeluarkan teks, dan memfilter output ke satu bidang menggunakan `--query` parameter, outputnya adalah satu baris nilai yang dipisahkan tab. Untuk mendapatkan setiap nilai ke baris terpisah, Anda dapat menempatkan bidang output dalam tanda kurung, seperti yang ditunjukkan pada contoh berikut.
Tab dipisahkan, output satu baris:
```
$ aws iam list-groups-for-user --user-name susan --output text --query "Groups[].GroupName"
```
```
HRDepartment Developers SpreadsheetUsers LocalAdmins
```
Setiap nilai pada barisnya sendiri dengan memasukkan `[GroupName]` tanda kurung:
```
$ aws iam list-groups-for-user --user-name susan --output text --query "Groups[].[GroupName]"
```
```
HRDepartment
Developers
SpreadsheetUsers
LocalAdmins
```
## Format keluaran tabel
`table`Format ini menghasilkan representasi yang dapat dibaca manusia dari AWS CLI output kompleks dalam bentuk tabel.
```
$ aws iam list-users --output table
```
```
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
| ListUsers |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
|| Users ||
|+----------------------------------------------------+---------------------------+---------------------------+----------+-----------------------+-------------+|
|| Arn | CreateDate | PasswordLastUsed | Path | UserId | UserName ||
|+----------------------------------------------------+---------------------------+---------------------------+----------+-----------------------+-------------+|
|| arn:aws:iam::123456789012:user/Admin | 2014-10-16T16:03:09+00:00 | 2016-06-03T18:37:29+00:00 | / | AIDA1111111111EXAMPLE | Admin ||
|| arn:aws:iam::123456789012:user/backup/backup-user | 2019-09-17T19:30:40+00:00 | | /backup/ | AIDA2222222222EXAMPLE | backup-user ||
|| arn:aws:iam::123456789012:user/cli-user | 2019-09-17T19:11:39+00:00 | | / | AIDA3333333333EXAMPLE | cli-user ||
+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
Anda dapat menggabungkan `--query` opsi dengan `table` format untuk menampilkan satu set elemen yang telah dipilih sebelumnya dari output mentah. Perhatikan perbedaan output antara notasi kamus dan daftar: pada contoh pertama, nama kolom diurutkan menurut abjad, dan pada contoh kedua, kolom yang tidak disebutkan namanya diurutkan seperti yang ditentukan oleh pengguna. Untuk informasi selengkapnya tentang `--query` opsi, lihat[Output penyaringan di AWS CLI](cli-usage-filter.md).
```
$ aws ec2 describe-volumes --query 'Volumes[*].{ID:VolumeId,InstanceId:Attachments[0].InstanceId,AZ:AvailabilityZone,Size:Size}' --output table
```
```
------------------------------------------------------
| DescribeVolumes |
+------------+----------------+--------------+-------+
| AZ | ID | InstanceId | Size |
+------------+----------------+--------------+-------+
| us-west-2a| vol-e11a5288 | i-a071c394 | 30 |
| us-west-2a| vol-2e410a47 | i-4b41a37c | 8 |
+------------+----------------+--------------+-------+
```
```
$ aws ec2 describe-volumes --query 'Volumes[*].[VolumeId,Attachments[0].InstanceId,AvailabilityZone,Size]' --output table
```
```
----------------------------------------------------
| DescribeVolumes |
+--------------+--------------+--------------+-----+
| vol-e11a5288| i-a071c394 | us-west-2a | 30 |
| vol-2e410a47| i-4b41a37c | us-west-2a | 8 |
+--------------+--------------+--------------+-----+
```
## Format keluaran mati
`off`Format menekan semua output perintah ke stdout. Ini berguna dalam skrip otomatisasi dan CI/CD saluran pipa di mana Anda hanya perlu memeriksa kode keluar perintah tanpa memproses output. Pesan kesalahan masih ditampilkan di stderr.
Contoh berikut menunjukkan bagaimana `off` format menekan output yang berhasil. Anda dapat memeriksa kode keluar untuk menentukan keberhasilan:
```
$ aws s3api list-buckets --output off
$ echo $?
0
```
Ini sangat berguna dalam skrip shell tempat Anda ingin memverifikasi sumber daya ada tanpa menangkap output:
```
#!/bin/bash
if aws s3api head-bucket --bucket my-bucket --output off 2>/dev/null; then
echo "Bucket exists"
else
echo "Bucket does not exist"
fi
```
**catatan**
`off`Formatnya hanya menekan stdout. Kesalahan masih ditulis ke stderr.
# Output kesalahan terstruktur di AWS CLI
Topik ini menjelaskan format keluaran kesalahan terstruktur untuk AWS Command Line Interface (AWS CLI). CLI menulis kesalahan ke stderr dan mendukung format berikut:
+ **[`enhanced`](#cli-error-format-enhanced)**(default) - Pesan kesalahan dengan detail tambahan ditampilkan sebaris. Gunakan untuk debugging yang dapat dibaca manusia.
+ **[`json`](#cli-error-format-json)**- Output diformat sebagai string [JSON](https://json.org/) dengan semua bidang kesalahan. Gunakan untuk otomatisasi dan skrip.
+ **[`yaml`](#cli-error-format-yaml)**- Output diformat sebagai string [YAMAL dengan](https://yaml.org/) semua bidang kesalahan. Gunakan untuk otomatisasi dan skrip.
+ **[`text`](#cli-error-format-text)**— Kesalahan format menggunakan pemformat teks. Gunakan untuk pemindaian visual cepat.
+ **[`table`](#cli-error-format-table)**— Kesalahan format menggunakan pemformat tabel. Gunakan untuk pemindaian visual cepat.
+ **[`legacy`](#cli-error-format-legacy)**— Format kesalahan asli tanpa detail terstruktur. Gunakan untuk kompatibilitas mundur.
## Mengkonfigurasi format kesalahan
Anda dapat mengonfigurasi format kesalahan menggunakan salah satu metode berikut:
Bendera baris perintah
```
$ aws --cli-error-format json
```
File konfigurasi (`~/.aws/config`)
```
[default]
cli_error_format = json
```
Variabel lingkungan
```
$ export AWS_CLI_ERROR_FORMAT=yaml
```
## Format keluaran kesalahan
Bagian berikut menjelaskan setiap format:
### Format yang disempurnakan (default)
Format yang disempurnakan menampilkan pesan kesalahan dengan detail tambahan sebaris untuk nilai sederhana. Untuk struktur yang kompleks, format memberikan petunjuk untuk menggunakan JSON atau YAMAL.
**Contoh: Konfigurasi wilayah tidak ada**
```
aws: [ERROR]: An error occurred (NoRegion): You must specify a region. You can also configure your region by running "aws configure".
```
**Contoh: Fungsi Lambda yang tidak ada dengan bidang tambahan**
```
aws: [ERROR]: An error occurred (ResourceNotFoundException) when calling the GetFunction operation: Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345
Additional error details:
Type: User
```
Bagian “Detail kesalahan tambahan” hanya menampilkan bidang yang ditentukan dalam model bentuk kesalahan layanan. Bidang yang tidak dimodelkan dari respons kesalahan tidak ditampilkan.
**Contoh: Bidang kesalahan kompleks**
```
An error occurred (TransactionCanceledException) when calling the TransactWriteItems operation: Transaction cancelled, please refer cancellation reasons for specific reasons [ConditionalCheckFailed, None]
Additional error details:
CancellationReasons:
Use "--cli-error-format json" or another error format to see the full details.
```
### Format JSON
Format JSON menyediakan representasi terstruktur dengan semua bidang kesalahan.
**Contoh: Konfigurasi wilayah tidak ada**
```
{
"Code": "NoRegion",
"Message": "You must specify a region. You can also configure your region by running \"aws configure\"."
}
```
**Contoh: Fungsi Lambda Tidak Ada**
```
{
"Code": "ResourceNotFoundException",
"Message": "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345",
"Type": "User"
}
```
### Format YAMAL
Format YAMAL menyediakan representasi terstruktur dengan semua bidang kesalahan.
**Contoh: Konfigurasi wilayah tidak ada**
```
Code: NoRegion
Message: You must specify a region. You can also configure your region by running "aws configure".
```
**Contoh: Fungsi Lambda Tidak Ada**
```
Code: ResourceNotFoundException
Message: "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345"
Type: User
```
### Format teks
Format teks menggunakan formatter yang sama dengan output perintah yang berhasil.
**Contoh: Fungsi Lambda Tidak Ada**
```
ResourceNotFoundException Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345 User
```
### Format tabel
Format tabel menggunakan formatter yang sama dengan output perintah yang berhasil.
**Contoh: Fungsi Lambda Tidak Ada**
```
------------------------------------------------------------------------------------------------------------------------------------|
| error |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
| Code | Message | Type |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
| ResourceNotFoundException | Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345 | User |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
```
### Format warisan
Format lama menyediakan format kesalahan asli tanpa detail terstruktur. Format ini tidak menyertakan awalan “Kesalahan terjadi (ErrorCode):” untuk pengecualian CLI.
**Contoh: Konfigurasi wilayah tidak ada**
```
aws: [ERROR]: You must specify a region. You can also configure your region by running "aws configure".
```
**Contoh: Fungsi Lambda Tidak Ada**
```
An error occurred (ResourceNotFoundException) when calling the GetFunction operation: Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345
```
**catatan**
Kesalahan sekarang secara konsisten menyertakan `aws: [ERROR]:` awalan untuk pengecualian CLI. Versi sebelumnya tidak selalu menyertakan awalan ini.
Pengecualian berikut selalu menggunakan format lama terlepas dari format kesalahan yang dikonfigurasi:
`UnknownArgumentError`— Menampilkan informasi penggunaan
Keyboard menyela () `KeyboardInterrupt`
## Contoh lengkap
Contoh berikut menunjukkan perintah dengan format kesalahan JSON:
```
$ aws lambda get-function \
--function-name nonexistent-function-12345 \
--cli-error-format json
```
Keluaran (stderr):
```
{
"Code": "ResourceNotFoundException",
"Message": "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345",
"Type": "User"
}
```
`Type`Bidang adalah anggota kesalahan model yang ditentukan dalam bentuk kesalahan layanan Lambda. Hanya bidang yang ditentukan dalam model kesalahan layanan yang disertakan dalam keluaran kesalahan terstruktur.
# Menggunakan opsi pagination di AWS CLI
Topik ini menjelaskan berbagai cara untuk melakukan paginasi output dari AWS Command Line Interface (AWS CLI).
Terutama ada dua cara untuk mengontrol pagination dari. AWS CLI
+ [Menggunakan parameter pagination sisi server.](#cli-usage-pagination-serverside)
+ [Menggunakan program paging sisi klien keluaran default Anda](#cli-usage-pagination-clientside).
Parameter pagination sisi server diproses terlebih dahulu dan output apa pun dikirim ke pagination sisi klien.
## Pagination sisi server
Untuk sebagian besar perintah yang menampilkan daftar item yang besar, AWS CLI memiliki beberapa opsi sisi server untuk mengontrol jumlah item yang disertakan dalam output saat AWS CLI memanggil API layanan untuk mengisi daftar. Pagination sisi server di AWS CLI diaktifkan oleh API AWS layanan, oleh karena itu opsi ini hanya berfungsi jika API layanan mengaktifkannya.
**Topics**
+ [--no-paginate](#cli-usage-pagination-nopaginate)
+ [--ukuran halaman](#cli-usage-pagination-pagesize)
+ [--maks-item](#cli-usage-pagination-maxitems)
+ [--starting-token](#cli-usage-pagination-startingtoken)
Secara default, AWS CLI menggunakan ukuran halaman yang ditentukan oleh layanan individu dan mengambil semua item yang tersedia. Misalnya, Amazon S3 memiliki ukuran halaman default 1000. Jika Anda menjalankan `aws s3api list-objects` bucket Amazon S3 yang berisi 3.500 objek, AWS CLI secara otomatis membuat empat panggilan ke Amazon S3, menangani logika pagination khusus layanan untuk Anda di latar belakang dan mengembalikan semua 3.500 objek di output akhir.
Untuk informasi tentang apakah perintah tertentu memiliki pagination sisi server, lihat panduan referensi [AWS CLI versi](https://docs.aws.amazon.com/cli/latest/reference/index.html) 2 .
### Cara menggunakan parameter --no-paginate
`--no-paginate`Opsi ini menonaktifkan token pagination berikut di sisi klien. Saat menggunakan perintah, secara default AWS CLI secara otomatis membuat beberapa panggilan untuk mengembalikan semua hasil yang mungkin untuk membuat pagination. Satu panggilan untuk setiap halaman. Menonaktifkan pagination memiliki AWS CLI satu-satunya panggilan sekali untuk halaman pertama hasil perintah.
Misalnya, jika Anda menjalankan `aws s3api list-objects` bucket Amazon S3 yang berisi 3.500 objek, AWS CLI satu-satunya yang membuat panggilan pertama ke Amazon S3, hanya mengembalikan 1.000 objek pertama dalam output akhir.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--no-paginate
{
"Contents": [
...
```
### Cara menggunakan parameter --page-size
Jika Anda melihat masalah saat menjalankan perintah daftar pada sejumlah besar sumber daya, ukuran halaman default mungkin terlalu tinggi. Hal ini dapat menyebabkan panggilan ke AWS layanan melebihi waktu maksimum yang diizinkan dan menghasilkan kesalahan “waktu habis”. Anda dapat menggunakan `--page-size` opsi untuk menentukan bahwa AWS CLI permintaan sejumlah kecil item dari setiap panggilan ke AWS layanan. AWS CLI Masih mengambil daftar lengkap, tetapi melakukan lebih banyak panggilan API layanan di latar belakang dan mengambil sejumlah kecil item dengan setiap panggilan. Ini memberi panggilan individu kesempatan yang lebih baik untuk berhasil tanpa batas waktu. Mengubah ukuran halaman tidak memengaruhi output; itu hanya memengaruhi jumlah panggilan API yang perlu dilakukan untuk menghasilkan output.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--page-size 100
{
"Contents": [
...
```
### Cara menggunakan parameter --max-items
Untuk memasukkan lebih sedikit item sekaligus dalam AWS CLI output, gunakan `--max-items` opsi. AWS CLI Masih menangani pagination dengan layanan seperti yang dijelaskan sebelumnya, tetapi hanya mencetak jumlah item pada waktu yang Anda tentukan.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--max-items 100
{
"NextToken": "eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ==",
"Contents": [
...
```
### Cara menggunakan parameter --starting-token
Jika jumlah item output (`--max-items`) lebih sedikit dari jumlah total item yang dikembalikan oleh panggilan API yang mendasarinya, outputnya menyertakan perintah `NextToken` yang dapat Anda teruskan ke perintah berikutnya untuk mengambil set item berikutnya. Contoh berikut menunjukkan bagaimana menggunakan `NextToken` nilai yang dikembalikan oleh contoh sebelumnya, dan memungkinkan Anda untuk mengambil 100 item kedua.
**catatan**
Parameter `--starting-token` tidak bisa nol atau kosong. Jika perintah sebelumnya tidak mengembalikan `NextToken` nilai, tidak ada lagi item untuk dikembalikan dan Anda tidak perlu memanggil perintah lagi.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--max-items 100 \
--starting-token eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ==
{
"Contents": [
...
```
AWS Layanan yang ditentukan mungkin tidak mengembalikan item dalam urutan yang sama setiap kali Anda menelepon. Jika Anda menentukan nilai yang berbeda untuk `--page-size` dan`--max-items`, Anda bisa mendapatkan hasil yang tidak terduga dengan item yang hilang atau digandakan. Untuk mencegah hal ini, gunakan nomor yang sama untuk `--page-size` dan `--max-items` untuk menyinkronkan AWS CLI pagination dengan pagination dari layanan yang mendasarinya. Anda juga dapat mengambil seluruh daftar dan melakukan operasi paging yang diperlukan secara lokal.
## Pager sisi klien
AWS CLI versi 2 menyediakan penggunaan program pager sisi klien untuk output. Secara default, fitur ini mengembalikan semua output melalui program pager default sistem operasi Anda.
Dalam urutan prioritas, Anda dapat menentukan pager output dengan cara berikut:
+ Menggunakan `cli_pager` pengaturan dalam `config` file di profil `default` atau bernama.
+ Menggunakan variabel `AWS_PAGER` lingkungan.
+ Menggunakan variabel `PAGER` lingkungan.
Dalam urutan prioritas, Anda dapat menonaktifkan semua penggunaan program paging eksternal dengan cara berikut:
+ Gunakan opsi baris `--no-cli-pager` perintah untuk menonaktifkan pager untuk penggunaan perintah tunggal.
+ Atur `cli_pager` pengaturan atau `AWS_PAGER` variabel ke string kosong.
**Topics**
+ [cli\$1pager](#cli-usage-pagination-clipager)
+ [AWS\$1PAGER](#cli-usage-pagination-awspager)
+ [--no-cli-pager](#cli-usage-pagination-noclipager)
+ [Bendera pager](#cli-usage-pagination-flags)
### Cara menggunakan pengaturan cli\$1pager
Anda dapat menyimpan pengaturan konfigurasi dan kredensional yang sering digunakan dalam file yang dikelola oleh file. AWS CLI Pengaturan di profil nama lebih diutamakan daripada pengaturan di profil. `default` Untuk informasi selengkapnya tentang pengaturan konfigurasi, lihat[Konfigurasi dan pengaturan file kredensi di AWS CLI](cli-configure-files.md).
Contoh berikut menetapkan default output pager untuk `less` program.
```
[default]
cli_pager=less
```
Contoh berikut menetapkan default untuk menonaktifkan penggunaan pager.
```
[default]
cli_pager=
```
### Cara mengatur variabel AWS\$1PAGER lingkungan
Contoh berikut menetapkan default output pager untuk `less` program. Untuk informasi lebih lanjut tentang variabel lingkungan, lihat[Mengkonfigurasi variabel lingkungan untuk AWS CLI](cli-configure-envvars.md).
------
#### [ Linux and macOS ]
```
$ export AWS_PAGER="less"
```
------
#### [ Windows ]
```
C:\> setx AWS_PAGER "less"
```
------
### Cara menggunakan no-cli-pager opsi --
Untuk menonaktifkan penggunaan pager pada satu perintah, gunakan `--no-cli-pager` opsi. Untuk informasi selengkapnya tentang opsi baris perintah, lihat[Opsi baris perintah di AWS CLI](cli-configure-options.md).
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--no-cli-pager
{
"Contents": [
...
```
### Cara menggunakan bendera pager
Anda dapat menentukan bendera untuk digunakan secara otomatis dengan program paging Anda. Bendera tergantung pada program paging yang Anda gunakan. Contoh di bawah ini adalah untuk default khas dan. `less` `more`
------
#### [ Linux and macOS ]
Jika Anda tidak menentukan sebaliknya, pager AWS CLI versi 2 menggunakan secara default adalah`less`. Jika Anda tidak memiliki variabel `LESS` lingkungan yang disetel, AWS CLI versi 2 menggunakan `FRX` bendera. Anda dapat menggabungkan bendera dengan menentukannya saat mengatur pager. AWS CLI
Contoh berikut menggunakan `S` bendera. Bendera ini kemudian digabungkan dengan `FRX` bendera default untuk membuat `FRXS` bendera akhir.
```
$ export AWS_PAGER="less -S"
```
Jika Anda tidak menginginkan `FRX` bendera apa pun, Anda dapat meniadakannya. Contoh berikut meniadakan `F` bendera untuk membuat `RX` bendera akhir.
```
$ export AWS_PAGER="less -+F"
```
Untuk informasi lebih lanjut tentang `less` bendera, lihat lebih [sedikit](http://manpages.org/less/1#options) di *manpages.org*.
------
#### [ Windows ]
Jika Anda tidak menentukan sebaliknya, pager AWS CLI versi 2 yang digunakan secara default adalah `more` tanpa tanda tambahan.
Contoh berikut menggunakan `/c` parameter.
```
C:\> setx AWS_PAGER "more /c"
```
Untuk informasi selengkapnya tentang `more` flag, lihat `[more](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/more)` di *Microsoft Docs*.
------
# Output penyaringan di AWS CLI
The AWS Command Line Interface (AWS CLI) memiliki penyaringan sisi server dan sisi klien yang dapat Anda gunakan secara individual atau bersama-sama untuk memfilter output Anda. AWS CLI Pemfilteran sisi server diproses terlebih dahulu dan mengembalikan output Anda untuk pemfilteran sisi klien.
+ Pemfilteran sisi server didukung oleh API, dan Anda biasanya menerapkannya dengan parameter. `--filter` Layanan hanya mengembalikan hasil yang cocok yang dapat mempercepat waktu respons HTTP untuk kumpulan data besar.
+ Pemfilteran sisi klien didukung oleh AWS CLI klien menggunakan parameter. `--query` Parameter ini memiliki kemampuan yang mungkin tidak dimiliki oleh penyaringan sisi server.
**Topics**
+ [Pemfilteran sisi server](#cli-usage-filter-server-side)
+ [Penyaringan sisi klien](#cli-usage-filter-client-side)
+ [Menggabungkan penyaringan sisi server dan sisi klien](#cli-usage-filter-combining)
+ [Sumber daya tambahan](#cli-usage-filter-resources)
## Pemfilteran sisi server
Pemfilteran sisi server di AWS CLI disediakan oleh API layanan. AWS AWS Layanan hanya mengembalikan catatan dalam respons HTTP yang cocok dengan filter Anda, yang dapat mempercepat waktu respons HTTP untuk kumpulan data besar. Karena pemfilteran sisi server ditentukan oleh API layanan, nama dan fungsi parameter bervariasi antar layanan. Beberapa nama parameter umum yang digunakan untuk penyaringan adalah:
+ `--filter`seperti dan [ce](https://docs.aws.amazon.com/cli/latest/reference/ce/get-cost-and-usage.html).
+ `--filters`
+ Nama dimulai dengan kata`filter`, misalnya `--filter-expression` untuk perintah.
[Untuk informasi tentang apakah perintah tertentu memiliki pemfilteran sisi server dan aturan pemfilteran, lihat panduan referensi referensi versi 2 .](https://docs.aws.amazon.com/cli/latest/reference/index.html)
## Penyaringan sisi klien
AWS CLI Ini menyediakan kemampuan penyaringan sisi klien berbasis JSON bawaan dengan parameter. `--query` `--query`Parameter adalah alat yang ampuh yang dapat Anda gunakan untuk menyesuaikan konten dan gaya output Anda. `--query`Parameter mengambil respons HTTP yang kembali dari server dan memfilter hasil sebelum menampilkannya. Karena seluruh respons HTTP dikirim ke klien sebelum pemfilteran, pemfilteran sisi klien bisa lebih lambat daripada penyaringan sisi server untuk kumpulan data besar.
Query menggunakan [JMESPath sintaks](https://jmespath.org/) untuk membuat ekspresi untuk memfilter output Anda. Untuk mempelajari JMESPath sintaks, lihat [Tutorial](https://jmespath.org/tutorial.html) di *JMESPath situs web*.
**penting**
Jenis keluaran yang Anda tentukan mengubah cara `--query` opsi beroperasi:
Jika Anda menentukan`--output text`, output diberi paginasi *sebelum* `--query` filter diterapkan, dan AWS CLI menjalankan kueri sekali pada *setiap halaman* output. Karena ini, kueri menyertakan elemen pencocokan pertama pada setiap halaman yang dapat menghasilkan output tambahan yang tidak terduga. Untuk memfilter output tambahan, Anda dapat menggunakan alat baris perintah lainnya seperti `head` atau`tail`.
Jika Anda menentukan `--output json` `--output yaml`,, atau `--output yaml-stream` output sepenuhnya diproses sebagai struktur asli tunggal sebelum `--query` filter diterapkan. AWS CLI Menjalankan kueri hanya sekali terhadap seluruh struktur, menghasilkan hasil yang difilter yang kemudian dikeluarkan.
**Topics**
+ [Sebelum Anda mulai](#cli-usage-filter-client-side-output)
+ [Pengidentifikasi](#cli-usage-filter-client-side-identifiers)
+ [Memilih dari daftar](#cli-usage-filter-client-side-select-list)
+ [Memfilter data bersarang](#cli-usage-filter-client-side-nested)
+ [Hasil perataan](#cli-usage-filter-client-side-specific-flattening)
+ [Pemfilteran untuk nilai tertentu](#cli-usage-filter-client-side-specific-values)
+ [Ekspresi perpipaan](#cli-usage-filter-client-side-pipe)
+ [Memfilter untuk beberapa nilai pengenal](#cli-usage-filter-client-side-miltiselect-list)
+ [Menambahkan label ke nilai pengenal](#cli-usage-filter-client-side-multiselect-hash)
+ [Fungsi](#cli-usage-filter-client-side-functions)
+ [`--query`Contoh lanjutan](#cli-usage-filter-client-side-advanced)
### Sebelum Anda mulai
**catatan**
Contoh ekspresi filter ini ditulis untuk shell seperti linux dasar. Saat menggunakan contoh ini, pastikan untuk menggunakan aturan kutipan yang benar untuk shell terminal Anda. Cara terminal Anda menafsirkan input Anda dapat sangat mengubah apa yang dikirim ke. AWS CLI Bagaimana terminal Anda membaca tanda kutip tunggal`'`, tanda kutip ganda`"`, atau backticks ``` dapat mengubah cara konten dibaca.
Untuk informasi selengkapnya, lihat [Menggunakan tanda kutip dan literal dengan string di AWS CLI](cli-usage-parameters-quoting-strings.md).
Output JSON berikut menunjukkan contoh dari apa `--query` parameter dapat menghasilkan. Outputnya menjelaskan tiga volume Amazon EBS yang dilampirkan ke instans Amazon EC2 yang terpisah.
#### Contoh Output
```
$ aws ec2 describe-volumes
{
"Volumes": [
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
}
```
### Pengidentifikasi
Identifier adalah label untuk nilai output. Saat membuat filter, Anda menggunakan pengidentifikasi untuk mempersempit hasil kueri Anda. Dalam contoh output berikut, semua pengidentifikasi seperti`Volumes`,`AvailabilityZone`, dan `AttachTime` disorot.
```
$ aws ec2 describe-volumes
{
"Volumes": [
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
}
```
Untuk informasi selengkapnya, lihat [Pengidentifikasi](https://jmespath.org/specification.html#identifiers ) di *JMESPath situs web*.
### Memilih dari daftar
Daftar atau array adalah pengidentifikasi yang diikuti oleh braket persegi "`[`" seperti `Volumes` dan `Attachments` di. [Sebelum Anda mulai](#cli-usage-filter-client-side-output)
**Sintaksis**
```
[ ]
```
Untuk memfilter semua output dari array, Anda dapat menggunakan notasi wildcard. Ekspresi [wildcard](http://jmespath.org/specification.html#wildcard-expressions) adalah ekspresi yang digunakan untuk mengembalikan elemen menggunakan `*` notasi.
Contoh berikut menanyakan semua `Volumes` konten.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
```
Untuk melihat volume tertentu dalam array dengan indeks, Anda memanggil indeks array. Misalnya, item pertama dalam `Volumes` array memiliki indeks 0, menghasilkan `Volumes[0]` kueri. Untuk informasi selengkapnya tentang indeks array, lihat [ekspresi indeks](http://jmespath.org/specification.html#index-expressions) di *JMESPathsitus web*.
```
$ aws ec2 describe-volumes \
--query 'Volumes[0]'
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
}
```
Untuk melihat rentang volume tertentu berdasarkan indeks, gunakan `slice` dengan sintaks berikut, di mana **awal** adalah indeks array awal, **stop** adalah indeks tempat filter berhenti memproses, dan **langkahnya** adalah interval lewati.
**Sintaksis**
```
[::]
```
Jika salah satu dari ini dihilangkan dari ekspresi irisan, mereka menggunakan nilai default berikut:
+ Mulai — Indeks pertama dalam daftar, 0.
+ Stop — Indeks terakhir dalam daftar.
+ Langkah - Tidak ada langkah melompati, di mana nilainya adalah 1.
Untuk mengembalikan hanya dua volume pertama, Anda menggunakan nilai awal 0, nilai stop 2, dan nilai langkah 1 seperti yang ditunjukkan pada contoh berikut.
```
$ aws ec2 describe-volumes \
--query 'Volumes[0:2:1]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
}
]
```
Karena contoh ini berisi nilai default, Anda dapat mempersingkat irisan dari `Volumes[0:2:1]` ke`Volumes[:2]`.
Contoh berikut menghilangkan nilai default dan mengembalikan setiap dua volume di seluruh array.
```
$ aws ec2 describe-volumes \
--query 'Volumes[::2]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
```
Langkah-langkah juga dapat menggunakan angka negatif untuk memfilter dalam urutan terbalik dari array seperti yang ditunjukkan pada contoh berikut.
```
$ aws ec2 describe-volumes \
--query 'Volumes[::-2]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
}
]
```
Untuk informasi lebih lanjut, lihat [Slices](https://jmespath.org/specification.html#slices) di *JMESPath situs web*.
### Memfilter data bersarang
Untuk mempersempit pemfilteran `Volumes[*]` untuk nilai bersarang, Anda menggunakan subexpressions dengan menambahkan periode dan kriteria filter Anda.
**Sintaksis**
```
.
```
Contoh berikut menunjukkan semua `Attachments` informasi untuk semua volume.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments'
[
[
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
[
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
[
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
]
]
```
Untuk memfilter lebih jauh ke dalam nilai bersarang, tambahkan ekspresi untuk setiap indentifier bersarang. Contoh berikut mencantumkan `State` untuk semua`Volumes`.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[*].State'
[
[
"attached"
],
[
"attached"
],
[
"attached"
]
]
```
### Hasil perataan
Untuk informasi lebih lanjut, lihat [SubExpressions](https://jmespath.org/specification.html#subexpressions)di *JMESPathsitus web*.
Anda dapat meratakan hasilnya `Volumes[*].Attachments[*].State` dengan menghapus notasi wildcard yang menghasilkan kueri. `Volumes[*].Attachments[].State` Meratakan sering berguna untuk meningkatkan keterbacaan hasil.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].State'
[
"attached",
"attached",
"attached"
]
```
Untuk informasi lebih lanjut, lihat [Flatten](https://jmespath.org/specification.html#flatten) di *JMESPath situs web*.
### Pemfilteran untuk nilai tertentu
Untuk memfilter nilai tertentu dalam daftar, Anda menggunakan ekspresi filter seperti yang ditunjukkan dalam sintaks berikut.
**Sintaksis**
```
? ]
```
Komparator ekspresi meliputi`==`,`!=`,`<`,, `<=``>`, dan`>=`. Contoh filter berikut `VolumeIds` untuk semua `Volumes` dalam file `Attached``State`.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[?State==`attached`].VolumeId'
[
[
"vol-e11a5288"
],
[
"vol-2e410a47"
],
[
"vol-a1b3c7nd"
]
]
```
Ini kemudian dapat diratakan sehingga menghasilkan contoh berikut.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[?State==`attached`].VolumeId[]'
[
"vol-e11a5288",
"vol-2e410a47",
"vol-a1b3c7nd"
]
```
Berikut contoh filter untuk semua `VolumeIds` `Volumes` yang memiliki ukuran kurang dari 20.
```
$ aws ec2 describe-volumes \
--query 'Volumes[?Size < `20`].VolumeId'
[
"vol-2e410a47",
"vol-a1b3c7nd"
]
```
Untuk informasi selengkapnya, lihat [Menyaring Ekspresi](https://jmespath.org/specification.html#filterexpressions) di *JMESPathsitus web*.
### Ekspresi perpipaan
Anda dapat menyalurkan hasil filter ke daftar baru, dan kemudian memfilter hasilnya dengan ekspresi lain menggunakan sintaks berikut:
**Sintaksis**
```
| ]
```
Contoh berikut mengambil hasil filter `Volumes[*].Attachments[].InstanceId` ekspresi dan output hasil pertama dalam array.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].InstanceId | [0]'
"i-a071c394"
```
Contoh ini melakukan ini dengan terlebih dahulu membuat array dari ekspresi berikut.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].InstanceId'
"i-a071c394",
"i-4b41a37c",
"i-1jd73kv8"
```
Dan kemudian mengembalikan elemen pertama dalam array itu.
```
"i-a071c394"
```
Untuk informasi lebih lanjut, lihat [Ekspresi Pipa](https://jmespath.org/specification.html#pipe-expressions) di *JMESPathsitus web*.
### Memfilter untuk beberapa nilai pengenal
Untuk memfilter beberapa pengidentifikasi, Anda menggunakan daftar multiselect dengan menggunakan sintaks berikut:
**Sintaksis**
```
[].[, ]
```
Dalam contoh berikut, `VolumeId` dan `VolumeType` disaring dalam `Volumes` daftar yang menghasilkan ekspresi berikut.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType]'
[
[
"vol-e11a5288",
"standard"
],
[
"vol-2e410a47",
"standard"
],
[
"vol-a1b3c7nd",
"standard"
]
]
```
Untuk menambahkan data bersarang ke daftar, Anda menambahkan daftar multipilih lainnya. Contoh berikut memperluas contoh sebelumnya dengan juga memfilter untuk `InstanceId` dan `State` dalam daftar bersarang`Attachments`. Ini menghasilkan ekspresi berikut.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType, Attachments[].[InstanceId, State]]'
[
[
"vol-e11a5288",
"standard",
[
[
"i-a071c394",
"attached"
]
]
],
[
"vol-2e410a47",
"standard",
[
[
"i-4b41a37c",
"attached"
]
]
],
[
"vol-a1b3c7nd",
"standard",
[
[
"i-1jd73kv8",
"attached"
]
]
]
]
```
Agar lebih mudah dibaca, ratakan ekspresi seperti yang ditunjukkan pada contoh berikut.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType, Attachments[].[InstanceId, State][]][]'
[
"vol-e11a5288",
"standard",
[
"i-a071c394",
"attached"
],
"vol-2e410a47",
"standard",
[
"i-4b41a37c",
"attached"
],
"vol-a1b3c7nd",
"standard",
[
"i-1jd73kv8",
"attached"
]
]
```
Untuk informasi selengkapnya, lihat [Daftar Multiselect](https://jmespath.org/specification.html#multiselectlist) di *JMESPath situs web*.
### Menambahkan label ke nilai pengenal
Untuk membuat output ini lebih mudah dibaca, gunakan hash multiselect dengan sintaks berikut.
**Sintaksis**
```
[].{