Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Output penyaringan di AWS CLI
<a name="cli-usage-filter"></a>

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
<a name="cli-usage-filter-server-side"></a>

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
<a name="cli-usage-filter-client-side"></a>

 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
<a name="cli-usage-filter-client-side-output"></a>

**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
<a name="cli-usage-filter-client-side-output-example"></a>

```
$ 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
<a name="cli-usage-filter-client-side-identifiers"></a>

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
<a name="cli-usage-filter-client-side-select-list"></a>

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**

```
<listName>[ ]
```

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**

```
<arrayName>[<start>:<stop>:<step>]
```

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
<a name="cli-usage-filter-client-side-nested"></a>

Untuk mempersempit pemfilteran `Volumes[*]` untuk nilai bersarang, Anda menggunakan subexpressions dengan menambahkan periode dan kriteria filter Anda.

**Sintaksis**

```
<expression>.<expression>
```

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
<a name="cli-usage-filter-client-side-specific-flattening"></a>

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
<a name="cli-usage-filter-client-side-specific-values"></a>

Untuk memfilter nilai tertentu dalam daftar, Anda menggunakan ekspresi filter seperti yang ditunjukkan dalam sintaks berikut.

**Sintaksis**

```
? <expression> <comparator> <expression>]
```

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
<a name="cli-usage-filter-client-side-pipe"></a>

Anda dapat menyalurkan hasil filter ke daftar baru, dan kemudian memfilter hasilnya dengan ekspresi lain menggunakan sintaks berikut: 

**Sintaksis**

```
<expression> | <expression>] 
```

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
<a name="cli-usage-filter-client-side-miltiselect-list"></a>

Untuk memfilter beberapa pengidentifikasi, Anda menggunakan daftar multiselect dengan menggunakan sintaks berikut: 

**Sintaksis**

```
<listName>[].[<expression>, <expression>]
```

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
<a name="cli-usage-filter-client-side-multiselect-hash"></a>

Untuk membuat output ini lebih mudah dibaca, gunakan hash multiselect dengan sintaks berikut.

**Sintaksis**

```
<listName>[].{<label>: <expression>, <label>: <expression>}
```

Label pengenal Anda tidak harus sama dengan nama pengenal. Contoh berikut menggunakan label `VolumeType` untuk `VolumeType` nilai-nilai.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[].{VolumeType: VolumeType}'
[
  {
    "VolumeType": "standard",
  },
  {
    "VolumeType": "standard",
  },
  {
    "VolumeType": "standard",
  }
]
```

Untuk mempermudah, contoh berikut menyimpan nama pengenal untuk setiap label dan menampilkan`VolumeId`,, `VolumeType``InstanceId`, dan `State` untuk semua volume:

```
$ aws ec2 describe-volumes \
    --query 'Volumes[].{VolumeId: VolumeId, VolumeType: VolumeType, InstanceId: Attachments[0].InstanceId, State: Attachments[0].State}'
[
  {
    "VolumeId": "vol-e11a5288",
    "VolumeType": "standard",
    "InstanceId": "i-a071c394",
    "State": "attached"
  },
  {
    "VolumeId": "vol-2e410a47",
    "VolumeType": "standard",
    "InstanceId": "i-4b41a37c",
    "State": "attached"
  },
  {
    "VolumeId": "vol-a1b3c7nd",
    "VolumeType": "standard",
    "InstanceId": "i-1jd73kv8",
    "State": "attached"
  }
]
```

*Untuk informasi lebih lanjut, lihat [hash Multiselect](https://jmespath.org/specification.html#multiselecthash) di situs web. JMESPath *

### Fungsi
<a name="cli-usage-filter-client-side-functions"></a>

 JMESPath Sintaks berisi banyak fungsi yang dapat Anda gunakan untuk kueri Anda. Untuk informasi tentang JMESPath fungsi, lihat [Fungsi bawaan](https://jmespath.org/specification.html#built-in-functions) di *JMESPathsitus web*.

Untuk menunjukkan bagaimana Anda dapat menggabungkan fungsi ke dalam kueri Anda, contoh berikut menggunakan `sort_by` fungsi tersebut. `sort_by`Fungsi mengurutkan array menggunakan ekspresi sebagai kunci sortir menggunakan sintaks berikut:

**Sintaksis**

```
sort_by(<listName>, <sort expression>)[].<expression>
```

Contoh berikut menggunakan contoh [hash multiselect](#cli-usage-filter-client-side-multiselect-hash) sebelumnya dan mengurutkan output berdasarkan. `VolumeId` 

```
$ aws ec2 describe-volumes \
    --query 'sort_by(Volumes, &VolumeId)[].{VolumeId: VolumeId, VolumeType: VolumeType, InstanceId: Attachments[0].InstanceId, State: Attachments[0].State}'
[
  {
    "VolumeId": "vol-2e410a47",
    "VolumeType": "standard",
    "InstanceId": "i-4b41a37c",
    "State": "attached"
  },
  {
    "VolumeId": "vol-a1b3c7nd",
    "VolumeType": "standard",
    "InstanceId": "i-1jd73kv8",
    "State": "attached"
  },
  {
    "VolumeId": "vol-e11a5288",
    "VolumeType": "standard",
    "InstanceId": "i-a071c394",
    "State": "attached"
  }
]
```

*Untuk informasi selengkapnya, lihat [sort\$1by di situs web](https://jmespath.org/specification.html#sort-by). JMESPath *

### `--query`Contoh lanjutan
<a name="cli-usage-filter-client-side-advanced"></a>

**Untuk mengekstrak informasi dari item tertentu**

Contoh berikut menggunakan `--query` parameter untuk menemukan item tertentu dalam daftar dan kemudian mengekstrak informasi dari item tersebut. Contoh ini mencantumkan semua yang `AvailabilityZones` terkait dengan titik akhir layanan yang ditentukan. Ini mengekstrak item dari `ServiceDetails` daftar yang telah ditentukan`ServiceName`, lalu mengeluarkan `AvailabilityZones` bidang dari item yang dipilih. 

```
$ aws --region us-east-1 ec2 describe-vpc-endpoint-services \
    --query 'ServiceDetails[?ServiceName==`com.amazonaws.us-east-1.ecs`].AvailabilityZones'
[
    [
        "us-east-1a",
        "us-east-1b",
        "us-east-1c",
        "us-east-1d",
        "us-east-1e",
        "us-east-1f"
    ]
]
```

**Untuk menampilkan snapshot setelah tanggal pembuatan yang ditentukan**

Contoh berikut menunjukkan cara membuat daftar semua snapshot Anda yang dibuat setelah tanggal tertentu, termasuk hanya beberapa bidang yang tersedia dalam output.

```
$ aws ec2 describe-snapshots --owner self \
    --output json \
    --query 'Snapshots[?StartTime>=`2018-02-07`].{Id:SnapshotId,VId:VolumeId,Size:VolumeSize}'
[
    {
        "id": "snap-0effb42b7a1b2c3d4",
        "vid": "vol-0be9bb0bf12345678",
        "Size": 8
    }
]
```

**Untuk menunjukkan yang terbaru AMIs**

Contoh berikut mencantumkan lima Gambar Mesin Amazon terbaru (AMIs) yang Anda buat, diurutkan dari yang terbaru ke yang paling lama.

```
$ aws ec2 describe-images \
    --owners self \
    --query 'reverse(sort_by(Images,&CreationDate))[:5].{id:ImageId,date:CreationDate}'
[
    {
        "id": "ami-0a1b2c3d4e5f60001",
        "date": "2018-11-28T17:16:38.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60002",
        "date": "2018-09-15T13:51:22.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60003",
        "date": "2018-08-19T10:22:45.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60004",
        "date": "2018-05-03T12:04:02.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60005",
        "date": "2017-12-13T17:16:38.000Z"
    }
]
```

**Untuk menampilkan instans Auto Scaling yang tidak sehat**

Contoh berikut hanya menampilkan `InstanceId` contoh yang tidak sehat dalam grup Auto Scaling yang ditentukan.

```
$ aws autoscaling describe-auto-scaling-groups \
    --auto-scaling-group-name My-AutoScaling-Group-Name \
    --output text \
    --query 'AutoScalingGroups[*].Instances[?HealthStatus==`Unhealthy`].InstanceId'
```

**Untuk menyertakan volume dengan tag yang ditentukan**

Contoh berikut menjelaskan semua contoh dengan `test` tag. Selama ada tag lain di samping yang `test` melekat pada volume, volume masih dikembalikan dalam hasil.

Ekspresi di bawah ini untuk mengembalikan semua `test` tag dengan tag dalam array. Setiap tag yang bukan `test` tag mengandung `null` nilai.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Tags[?Value == `test`]'
```

**Untuk mengecualikan volume dengan tag yang ditentukan**

Contoh berikut menjelaskan semua contoh tanpa `test` tag. Menggunakan `?Value != `test`` ekspresi sederhana tidak berfungsi untuk mengecualikan volume karena volume dapat memiliki beberapa tag. Selama ada tag lain di samping yang `test` melekat pada volume, volume masih dikembalikan dalam hasil.

Untuk mengecualikan semua volume dengan `test` tag, mulailah dengan ekspresi di bawah ini untuk mengembalikan semua tag dengan `test` tag dalam array. Setiap tag yang bukan `test` tag mengandung `null` nilai.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Tags[?Value == `test`]'
```

Kemudian saring semua `test` hasil positif menggunakan `not_null` fungsi tersebut. 

```
$ aws ec2 describe-volumes \
    --query 'Volumes[?!not_null(Tags[?Value == `test`].Value)]'
```

Pipa hasil untuk meratakan hasil yang menghasilkan kueri berikut.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[?!not_null(Tags[?Value == `test`].Value)] | []'
```

## Menggabungkan penyaringan sisi server dan sisi klien
<a name="cli-usage-filter-combining"></a>

Anda dapat menggunakan penyaringan sisi server dan sisi klien secara bersamaan. Pemfilteran sisi server diselesaikan terlebih dahulu, yang mengirimkan data ke klien yang kemudian difilter oleh parameter. `--query` Jika Anda menggunakan kumpulan data besar, menggunakan pemfilteran sisi server terlebih dahulu dapat menurunkan jumlah data yang dikirim ke klien untuk setiap AWS CLI panggilan, sambil tetap menjaga kustomisasi kuat yang disediakan oleh penyaringan sisi klien.

Contoh berikut mencantumkan volume Amazon EC2 menggunakan pemfilteran sisi server dan sisi klien. Layanan memfilter daftar semua volume terlampir di `us-west-2a` Availability Zone. `--query`Parameter selanjutnya membatasi output hanya volume dengan `Size` nilai yang lebih besar dari 50, dan hanya menampilkan bidang tertentu dengan nama yang ditentukan pengguna.

```
$ aws ec2 describe-volumes \
    --filters "Name=availability-zone,Values=us-west-2a" "Name=status,Values=attached" \
    --query 'Volumes[?Size > `50`].{Id:VolumeId,Size:Size,Type:VolumeType}'
[
    {
        "Id": "vol-0be9bb0bf12345678",
        "Size": 80,
        "VolumeType": "gp2"
    }
]
```

Contoh berikut mengambil daftar gambar yang memenuhi beberapa kriteria. Kemudian menggunakan `--query` parameter untuk mengurutkan output dengan`CreationDate`, memilih hanya yang terbaru. Akhirnya, ini menampilkan gambar `ImageId` yang satu itu.

```
$ aws ec2 describe-images \
    --owners amazon \
    --filters "Name=name,Values=amzn*gp2" "Name=virtualization-type,Values=hvm" "Name=root-device-type,Values=ebs" \
    --query "sort_by(Images, &CreationDate)[-1].ImageId" \
    --output text
ami-00ced3122871a4921
```

Contoh berikut menampilkan jumlah volume yang tersedia yang lebih dari 1000 IOPS dengan menggunakan `length` untuk menghitung berapa banyak dalam daftar.

```
$ aws ec2 describe-volumes \
    --filters "Name=status,Values=available" \
    --query 'length(Volumes[?Iops > `1000`])'
3
```

Contoh berikut mengambil nama-nama grup Auto Scaling yang menggunakan konfigurasi peluncuran dalam yang Wilayah AWS ditentukan yang menggunakan tumpukan. CloudFormation 

```
$ aws autoscaling describe-auto-scaling-groups --region us-west-2 \
  --filters Name=tag-key,Values=aws:cloudformation:stack-name \
  --query 'AutoScalingGroups[?LaunchConfigurationName!=`null`].AutoScalingGroupName'
[
    "group-1",
    "group-2",
    "group-3"
]
```

## Sumber daya tambahan
<a name="cli-usage-filter-resources"></a>

**AWS CLI autoprompt**  
Saat mulai menggunakan ekspresi filter, Anda dapat menggunakan fitur prompt otomatis di AWS CLI versi 2. Fitur auto-prompt menyediakan pratinjau ketika Anda menekan tombol **F5**. Untuk informasi selengkapnya, lihat [Mengaktifkan dan menggunakan command prompt di AWS CLI](cli-usage-parameters-prompting.md).

**JMESPath Terminal**  
JMESPath Terminal adalah perintah terminal interaktif untuk bereksperimen dengan JMESPath ekspresi yang digunakan untuk pemfilteran sisi klien. Menggunakan `jpterm` perintah, terminal menampilkan hasil kueri langsung saat Anda mengetik. Anda dapat langsung AWS CLI menyalurkan output ke terminal, memungkinkan eksperimen kueri lanjutan.   
Berikut contoh pipa `aws ec2 describe-volumes` output langsung ke JMESPath Terminal.  

```
$ aws ec2 describe-volumes | jpterm
```
Untuk informasi selengkapnya tentang JMESPath Terminal dan petunjuk penginstalan, lihat [JMESPathTerminal](https://github.com/jmespath/jmespath.terminal) aktif *GitHub*.

**utilitas jq**  
`jq`Utilitas ini memberi Anda cara untuk mengubah output Anda di sisi klien ke format output yang Anda inginkan. Untuk informasi lebih lanjut tentang `jq` dan petunjuk pemasangan, lihat [jq](https://stedolan.github.io/jq/) on *GitHub*.