Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Uscita di filtraggio nel AWS CLI
<a name="cli-usage-filter"></a>

 AWS Command Line Interface (AWS CLI) dispone di filtri sia sul lato server che sul lato client che è possibile utilizzare singolarmente o insieme per filtrare l'output. AWS CLI Il filtraggio lato server viene elaborato per primo e restituisce l’output per il filtraggio lato client. 
+ Il filtraggio lato server è supportato dall’API e di solito lo si implementa con un parametro `--filter`. Il servizio restituisce solo risultati corrispondenti che possono velocizzare i tempi di risposta HTTP per set di dati di grandi dimensioni.
+ Il filtraggio lato client è supportato dal client che utilizza il parametro. AWS CLI `--query` Questo parametro ha funzionalità che il filtraggio lato server potrebbe non avere.

**Topics**
+ [

## Filtro lato server
](#cli-usage-filter-server-side)
+ [

## Filtro lato client
](#cli-usage-filter-client-side)
+ [

## Combinazione di filtri lato server e lato client
](#cli-usage-filter-combining)
+ [

## Risorse aggiuntive
](#cli-usage-filter-resources)

## Filtro lato server
<a name="cli-usage-filter-server-side"></a>

Il filtraggio lato server in AWS CLI è fornito dall'API del servizio. AWS Il servizio AWS restituisce solo i record nella risposta HTTP che corrispondono al filtro, il che può velocizzare i tempi di risposta HTTP per set di dati di grandi dimensioni. Poiché il filtraggio lato server è definito dall’API del servizio, i nomi e le funzioni dei parametri variano tra i servizi. Alcuni nomi di parametri comuni utilizzati per il filtraggio sono: 
+ `--filter` come [ses](https://docs.aws.amazon.com/cli/latest/reference/ses/create-receipt-filter.html) e [ce](https://docs.aws.amazon.com/cli/latest/reference/ce/get-cost-and-usage.html). 
+ `--filters` come [ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-volumes.html), [autoscaling](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/describe-tags.html) e [rds](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html). 
+ Nomi che iniziano con la parola `filter`, ad esempio `--filter-expression` per il comando [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/scan.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/scan.html).



## Filtro lato client
<a name="cli-usage-filter-client-side"></a>

 AWS CLI Fornisce funzionalità di filtraggio lato client basate su JSON integrate con il parametro. `--query` Il parametro `--query` è uno strumento potente che puoi utilizzare per personalizzare il contenuto e lo stile del tuo output. Il parametro `--query` prende la risposta HTTP che arriva dal server e filtra i risultati prima di visualizzarli. Poiché l’intera risposta HTTP viene inviata al client prima del filtraggio, il filtraggio lato client può essere più lento del filtraggio lato server per set di dati di grandi dimensioni.

L'interrogazione utilizza la [JMESPath sintassi per creare espressioni](https://jmespath.org/) per filtrare l'output. *Per imparare la JMESPath sintassi, consulta il [Tutorial](https://jmespath.org/tutorial.html) sul sito web. JMESPath *

**Importante**  
Il tipo di output specificato influenza il funzionamento dell’opzione `--query`:  
Se lo specificate`--output text`, l'output viene impaginato *prima dell'*applicazione del `--query` filtro e quindi AWS CLI esegue la query una volta su *ogni pagina* dell'output. Per questo motivo, la query include il primo elemento corrispondente in ogni pagina, eventualmente generando un output aggiuntivo inaspettato. È inoltre possibile utilizzare altri strumenti a riga di comando, ad esempio `head` o `tail` per filtrare ulteriormente l’output.
Se si specifica `--output json`, `--output yaml` o `--output yaml-stream`, l’output viene completamente elaborato come una struttura singola nativa prima dell’applicazione del filtro `--query`. AWS CLI Esegue la query solo una volta sull'intera struttura, producendo un risultato filtrato che viene quindi emesso.

**Topics**
+ [

### Prima di iniziare
](#cli-usage-filter-client-side-output)
+ [

### Identificatori
](#cli-usage-filter-client-side-identifiers)
+ [

### Selezione da un elenco
](#cli-usage-filter-client-side-select-list)
+ [

### Filtrare i dati nidificati
](#cli-usage-filter-client-side-nested)
+ [

### Appiattimento dei risultati
](#cli-usage-filter-client-side-specific-flattening)
+ [

### Filtro per valori specifici
](#cli-usage-filter-client-side-specific-values)
+ [

### Espressioni con reindirizzamento
](#cli-usage-filter-client-side-pipe)
+ [

### Filtraggio in base a molteplici identificatori
](#cli-usage-filter-client-side-miltiselect-list)
+ [

### Aggiunta di etichette ai valori degli identificatori
](#cli-usage-filter-client-side-multiselect-hash)
+ [

### Funzioni
](#cli-usage-filter-client-side-functions)
+ [

### Esempi avanzati di `--query`
](#cli-usage-filter-client-side-advanced)

### Prima di iniziare
<a name="cli-usage-filter-client-side-output"></a>

**Nota**  
Questi esempi di espressioni di filtro sono scritti per shell di base in stile Linux. Quando usi questi esempi, assicurati di utilizzare le regole di quotazione corrette per la shell del terminale. Il modo in cui il terminale interpreta i tuoi input può modificare notevolmente ciò che viene inviato alla AWS CLI. Il modo in cui il terminale legge le virgolette singole `'`, le virgolette doppie `"` o le virgolette inverse ``` può cambiare il modo in cui viene letto il contenuto.  
Per ulteriori informazioni, consulta [Utilizzo di virgolette e valori letterali con stringhe in AWS CLI](cli-usage-parameters-quoting-strings.md).

Il seguente output JSON mostra un esempio di ciò che può produrre il parametro `--query`. L’output illustra tre volumi Amazon EBS collegati a istanze Amazon EC2 separate.

#### Output di esempio
<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
    }
  ]
}
```

### Identificatori
<a name="cli-usage-filter-client-side-identifiers"></a>

Gli identificatori sono le etichette per i valori di output. Quando crei dei filtri, utilizzi gli identificatori per restringere i risultati delle query. Nel seguente esempio di output, tutti gli identificatori come `Volumes`, `AvailabilityZone` e `AttachTime` sono evidenziati. 

```
$ 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
    }
  ]
}
```

*Per ulteriori informazioni, vedere [Identificatori](https://jmespath.org/specification.html#identifiers ) sul sito Web. JMESPath *

### Selezione da un elenco
<a name="cli-usage-filter-client-side-select-list"></a>

Un elenco o una matrice è un identificatore seguito da una parentesi quadra “`[`” come `Volumes` e `Attachments` in [Prima di iniziare](#cli-usage-filter-client-side-output). 

**Sintassi**

```
<listName>[ ]
```

Per filtrare tutto l’output di un array, puoi utilizzare la notazione con caratteri jolly. Le espressioni [con caratteri jolly](http://jmespath.org/specification.html#wildcard-expressions) sono espressioni utilizzate per restituire elementi utilizzando la notazione `*`. 

L’esempio seguente esegue una query su tutti i contenuti di `Volumes`.

```
$ 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
  }
]
```

Per visualizzare un volume specifico nell’array per indice, chiami l’indice dell’array. Ad esempio, il primo elemento dell’array `Volumes` presenta un indice pari a 0, che appare nella query `Volumes[0]`. *Per ulteriori informazioni sugli indici degli array, consultate le [espressioni di indice sul sito Web](http://jmespath.org/specification.html#index-expressions). JMESPath*

```
$ 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
}
```

Per visualizzare un intervallo specifico di volumi per indice, utilizza `slice` con la seguente sintassi, dove **start** è l’indice iniziale dell’array, **stop** è l’indice in cui il filtro interrompe l’elaborazione e **step** è l’intervallo di salto. 

**Sintassi**

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

Se uno di questi valori viene omesso dall’espressione slice, vengono utilizzati i seguenti valori predefiniti:
+ Start - Il primo indice dell’elenco, 0.
+ Stop - L’ultimo indice dell’elenco.
+ Step - Non viene saltato nessun elemento, il valore è quindi 1.

Per restituire solo i primi due volumi, utilizza un valore di Start pari a 0, un valore di Stop pari a 2 e un valore di Step pari a 1, come illustrato nell’esempio seguente.

```
$ 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
  }
]
```

Poiché questo esempio contiene valori predefiniti, puoi abbreviare il comando slice da `Volumes[0:2:1]` a `Volumes[:2]`.

L’esempio seguente omette i valori predefiniti e restituisce un volume ogni due dell’intero 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
  }
]
```

Inoltre, i passaggi possono utilizzare numeri negativi per filtrare in ordine inverso un array, come mostrato nell’esempio seguente. 

```
$ 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
  }
]
```

*Per ulteriori informazioni, consultate [Slices](https://jmespath.org/specification.html#slices) sul JMESPath sito Web.*

### Filtrare i dati nidificati
<a name="cli-usage-filter-client-side-nested"></a>

Per restringere il filtraggio dei `Volumes[*]` in caso di valori nidificati, utilizza le sottoespressioni aggiungendo un punto e i criteri di filtro.

**Sintassi**

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

L’esempio seguente visualizza tutte le informazioni `Attachments` per tutti i volumi.

```
$ 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"
    }
  ]
]
```

Per filtrare ulteriormente i valori nidificati, aggiungi l’espressione per ogni identificatore nidificato. L’esempio seguente elenca gli `State` per tutti i `Volumes`.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[*].State'
[
  [
    "attached"
  ],
  [
    "attached"
  ],
  [
    "attached"
  ]
]
```

### Appiattimento dei risultati
<a name="cli-usage-filter-client-side-specific-flattening"></a>

Per ulteriori informazioni, consulta [SubExpressions](https://jmespath.org/specification.html#subexpressions)il *JMESPathsito Web*.

È possibile appiattire i risultati del comando `Volumes[*].Attachments[*].State` rimuovendo la notazione con caratteri jolly risultante dalla query `Volumes[*].Attachments[].State`. L’appiattimento spesso è utile per migliorare la leggibilità dei risultati.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[].State'
[
  "attached",
  "attached",
  "attached"
]
```

*Per ulteriori informazioni, vedere [Flatten sul sito](https://jmespath.org/specification.html#flatten) Web. JMESPath *

### Filtro per valori specifici
<a name="cli-usage-filter-client-side-specific-values"></a>

Per filtrare valori specifici in un elenco, utilizza un’espressione di filtro come illustrato nella sintassi seguente.

**Sintassi**

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

I comparatori di espressioni includono `==`, `!=`, `<`, `<=`, `>` e `>=`. L’esempio seguente filtra i `VolumeIds` per tutti i `Volumes` in un `Attached``State`.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[?State==`attached`].VolumeId'
[
  [
    "vol-e11a5288"
  ],
  [
    "vol-2e410a47"
  ],
  [
    "vol-a1b3c7nd"
  ]
]
```

Questo risultato può quindi essere appiattito, ottenendo l’esempio seguente.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[?State==`attached`].VolumeId[]'
[
  "vol-e11a5288",
  "vol-2e410a47",
  "vol-a1b3c7nd"
]
```

L’esempio seguente filtra i `VolumeIds` di tutti i `Volumes` che hanno una dimensione inferiore a 20.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[?Size < `20`].VolumeId'
[
  "vol-2e410a47",
  "vol-a1b3c7nd"
]
```

*Per ulteriori informazioni, consulta [Filter Expressions](https://jmespath.org/specification.html#filterexpressions) sul JMESPath sito Web.*

### Espressioni con reindirizzamento
<a name="cli-usage-filter-client-side-pipe"></a>

È possibile reindirizzare i risultati di un filtro a un nuovo elenco e quindi filtrare il risultato con un’altra espressione utilizzando la sintassi seguente: 

**Sintassi**

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

L’esempio seguente prende i risultati del filtro dell’espressione `Volumes[*].Attachments[].InstanceId` e restituisce il primo risultato nell’array. 

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[].InstanceId | [0]'
"i-a071c394"
```

Questo esempio esegue questa operazione creando innanzitutto l’array dalla seguente espressione.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[].InstanceId'
"i-a071c394",
  "i-4b41a37c",
  "i-1jd73kv8"
```

In seguito restituisce il primo elemento di tale array.

```
"i-a071c394"
```

Per ulteriori informazioni, consulta [Pipe Expressions](https://jmespath.org/specification.html#pipe-expressions) sul *JMESPathsito Web*.

### Filtraggio in base a molteplici identificatori
<a name="cli-usage-filter-client-side-miltiselect-list"></a>

Per filtrare più identificatori, utilizza un elenco a selezione multipla con la seguente sintassi: 

**Sintassi**

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

Nell’esempio seguente, `VolumeId` e `VolumeType` vengono filtrati nell’elenco `Volumes` risultante dalla seguente espressione.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[].[VolumeId, VolumeType]'
[
  [
    "vol-e11a5288",
    "standard"
  ],
  [
    "vol-2e410a47",
    "standard"
  ],
  [
    "vol-a1b3c7nd",
    "standard"
  ]
]
```

Per aggiungere dati annidati all’elenco, aggiungi un altro elenco a selezione multipla. L’esempio seguente amplia l’esempio precedente filtrando anche per `InstanceId` e `State` nell’elenco nidificato `Attachments`. I risultati sono illustrati di seguito.

```
$ 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"
      ]
    ]
  ]
]
```

Per renderli più leggibili, appiattisci l’espressione come mostrato nell’esempio seguente.

```
$ 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"
  ]
]
```

*Per ulteriori informazioni, consultate l'[elenco Multiselect sul sito Web](https://jmespath.org/specification.html#multiselectlist). JMESPath *

### Aggiunta di etichette ai valori degli identificatori
<a name="cli-usage-filter-client-side-multiselect-hash"></a>

Per facilitare la lettura di questo output, utilizza un hash a selezione multipla con la seguente sintassi.

**Sintassi**

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

L’etichetta identificativa non deve necessariamente corrispondere al nome dell’identificatore. L’esempio seguente utilizza l’etichetta `VolumeType` per i valori `VolumeType`.

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

Per semplicità, l’esempio seguente mantiene i nomi degli identificatori per ogni etichetta e visualizza `VolumeId`, `VolumeType`, `InstanceId` e `State` per tutti i volumi:

```
$ 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"
  }
]
```

*Per ulteriori informazioni, consulta [Multiselect](https://jmespath.org/specification.html#multiselecthash) hash sul sito Web. JMESPath *

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

La JMESPath sintassi contiene molte funzioni che è possibile utilizzare per le query. *Per informazioni sulle JMESPath funzioni, consulta [Funzioni integrate sul JMESPath sito](https://jmespath.org/specification.html#built-in-functions) Web.*

Per dimostrare come incorporare una funzione nelle query, l’esempio seguente utilizza la funzione `sort_by`. La funzione `sort_by` ordina un array utilizzando un’espressione come chiave di ordinamento seguendo la sintassi seguente:

**Sintassi**

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

L’esempio seguente utilizza il precedente [esempio di hash a selezione multipla](#cli-usage-filter-client-side-multiselect-hash) e ordina l’output per `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"
  }
]
```

*Per ulteriori informazioni, vedere [sort\$1by sul sito](https://jmespath.org/specification.html#sort-by) Web. JMESPath *

### Esempi avanzati di `--query`
<a name="cli-usage-filter-client-side-advanced"></a>

**Come estrarre informazioni da un elemento specifico**

L’esempio seguente utilizza il parametro `--query` per trovare un determinato elemento in un elenco e quindi estrae le informazioni da tale elemento. L’esempio seguente elenca tutte le `AvailabilityZones` associate all’endpoint del servizio specificato. Estrae l’elemento dall’elenco `ServiceDetails` che ha specificato `ServiceName`, quindi emette il campo `AvailabilityZones` da questo elemento selezionato. 

```
$ 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"
    ]
]
```

**Come mostrare snapshot dopo la data di creazione specificata**

L’esempio seguente visualizza come creare un elenco di tutte le snapshot che sono state create dopo una data specifica, includendo solo alcuni dei campi disponibili nell’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
    }
]
```

**Per mostrare le più recenti AMIs**

L'esempio seguente elenca le cinque Amazon Machine Images (AMIs) più recenti che hai creato, ordinate dalla più recente alla meno recente.

```
$ 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"
    }
]
```

**Come mostrare istanze con dimensionamento automatico non integre**

L’esempio seguente visualizza solo l’`InstanceId` per qualsiasi istanza non integra nel gruppo Auto Scaling specificato.

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

**Come includere i volumi con il tag specificato**

L’esempio seguente descrive tutte le istanze con un tag `test`. Finché è presente un altro tag oltre a `test` associato al volume, il volume viene comunque restituito nei risultati.

L’espressione seguente restituisce tutti i tag con il tag `test` in un array. Tutti i tag che non sono il tag `test` contengono un valore `null`.

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

**Come escludere i volumi con il tag specificato**

L’esempio seguente descrive tutte le istanze senza un tag `test`. L’uso di una semplice espressione `?Value != `test`` non funziona per escludere un volume poiché i volumi possono avere più tag. Finché è presente un altro tag oltre a `test` associato al volume, il volume viene comunque restituito nei risultati.

Per escludere tutti i volumi con il tag `test`, inizia con l’espressione seguente per restituire tutti i tag con il tag `test` in un array. Tutti i tag che non sono il tag `test` contengono un valore `null`.

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

Quindi filtra tutti i risultati positivi di `test` utilizzando la funzione `not_null`. 

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

Reindirizza i risultati per appiattirli ottenendo la seguente query.

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

## Combinazione di filtri lato server e lato client
<a name="cli-usage-filter-combining"></a>

Puoi utilizzare filtri lato server e lato client insieme. Per prima cosa viene completato il filtraggio lato server, che invia i dati al client che vengono quindi filtrati attraverso il parametro `--query`. Se utilizzi set di dati di grandi dimensioni, utilizzando innanzitutto il filtro lato server puoi ridurre la quantità di dati inviati al client per ogni AWS CLI chiamata, pur mantenendo la potente personalizzazione fornita dal filtro lato client.

L’esempio seguente elenca i volumi Amazon EC2 che utilizzano filtri lato server e lato client. Il servizio filtra un elenco di tutti i volumi collegati nella zona di disponibilità `us-west-2a`. Il parametro `--query` limita ulteriormente l’output ai soli volumi con un valore `Size` maggiore di 50 e mostra solo i campi specificati con nomi definiti dall’utente.

```
$ 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"
    }
]
```

L’esempio seguente consente di recuperare un elenco di immagini che soddisfano diversi criteri. Quindi utilizza il parametro `--query` per ordinare l’output in base a `CreationDate`, selezionando solo il più recente. Infine, visualizza l’`ImageId` di tale immagine.

```
$ 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
```

Nell’esempio seguente viene visualizzato il numero di volumi disponibili che sono più di 1000 IOPS utilizzando `length` per contarne il numero in un elenco.

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

L'esempio seguente recupera i nomi dei gruppi di Auto Scaling che utilizzano configurazioni di avvio negli stack Regione AWS specificati. 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"
]
```

## Risorse aggiuntive
<a name="cli-usage-filter-resources"></a>

**Prompt automatico della AWS CLI **  
Quando si inizia a utilizzare le espressioni di filtro, è possibile utilizzare la funzionalità di prompt automatico nella AWS CLI versione 2. La funzionalità di prompt automatico fornisce un’anteprima quando premi il tasto **F5**. Per ulteriori informazioni, consulta [Attivazione e utilizzo dei prompt dei comandi in AWS CLI](cli-usage-parameters-prompting.md).

**JMESPath Terminale**  
JMESPath Terminal è un comando terminale interattivo per sperimentare JMESPath espressioni utilizzate per il filtraggio lato client. Utilizzando il comando `jpterm`, il terminale mostra immediatamente i risultati delle query durante la digitazione. È possibile reindirizzare l' AWS CLI output direttamente al terminale, abilitando la sperimentazione avanzata di interrogazioni.   
L'esempio seguente reindirizza l'`aws ec2 describe-volumes`output direttamente a Terminal. JMESPath   

```
$ aws ec2 describe-volumes | jpterm
```
Per ulteriori informazioni su JMESPath Terminal e istruzioni di installazione, consulta [JMESPathTerminal](https://github.com/jmespath/jmespath.terminal) on *GitHub*.

**Utility jq**  
L’utility `jq` offre un modo per trasformare l’output sul lato client nel formato di output desiderato. Per ulteriori informazioni `jq` e istruzioni di installazione, vedere [jq](https://stedolan.github.io/jq/) on *GitHub*.