.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Estrae i campi `loggingTime`, `loggingType` e `loggingMessage`, filtra per log eventi che contengono le stringhe `ERROR` o `INFO` e quindi mostra solo i campi `loggingMessage` e `loggingType` per gli eventi che contengono una stringa `ERROR`.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# sort
Utilizza `sort` per visualizzare i log eventi in ordine crescente (`asc`) o decrescente (`desc`) di un campo specificato. Puoi utilizzare questa opzione con il comando `limit` per creare query "primi N" o "ultimi N".
L'algoritmo di ordinamento è una versione aggiornata dell'ordinamento naturale. Se si ordina in ordine crescente, viene utilizzata la seguente logica.
+ Tutti i valori non numerici vengono prima di tutti i valori numerici. *I valori numerici* sono valori che includono solo numeri, non una combinazione di numeri e altri caratteri.
+ Per i valori non numerici, l'algoritmo raggruppa caratteri numerici consecutivi e caratteri alfabetici consecutivi in blocchi separati per il confronto. Ordina le porzioni non numeriche in base ai valori Unicode e le porzioni numeriche in base alla lunghezza prima e poi in base al valore numerico.
[Per ulteriori informazioni sull'ordine Unicode, vedere Elenco dei caratteri Unicode.](https://en.wikipedia.org/wiki/List_of_Unicode_characters)
Ad esempio, quanto segue è il risultato di un ordinamento in ordine crescente.
```
!: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sorted by unicode order
#
*%04
0# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Alphanumeric starting with numbers
5A
111A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Starts with more digits than 5A, so it sorted to be later than 5A
2345_
@ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2345 is compared with @ in the unicode order,
@_
A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Values starting with letters
A9876fghj
a12345hfh
0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Number values
01
1
2
3
```
Se si esegue l'ordinamento in ordine decrescente, i risultati dell'ordinamento sono invertiti.
Ad esempio, la seguente query per i log di flusso di Amazon VPC individua i primi 15 trasferimenti di pacchetti tra gli host.
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
# stats
Utilizza `stats` per creare visualizzazioni dei dati di log come grafici a barre, grafici a linee e grafici ad area in pila. Ciò consente di identificare in modo più efficiente i modelli nei dati di registro. CloudWatch Logs Insights genera visualizzazioni per le query che utilizzano la `stats` funzione e una o più funzioni di aggregazione.
Ad esempio, la seguente query in un gruppo di log Route 53 restituisce visualizzazioni che mostrano la distribuzione dei record di Route 53 all'ora, per tipo di query.
```
stats count(*) by queryType, bin(1h)
```
Tutte queste query possono produrre grafici a barre. Se la query utilizza la funzione `bin()` per raggruppare i dati per un campo nel tempo, è anche possibile visualizzare grafici a linee e grafici ad area in pila.
La funzione `bin` supporta le seguenti abbreviazioni e unità di tempo. Per tutte le unità e le abbreviazioni che includono più di un carattere, è supportata l'aggiunta di s per il plurale. Quindi entrambi `hr` e `hrs` lavorano per specificare gli orari.
+ `millisecond` `ms` `msec`
+ `second` `s` `sec`
+ `minute` `m` `min`
+ `hour` `h` `hr`
+ `day` `d`
+ `week` `w`
+ `month` `mo` `mon`
+ `quarter` `q` `qtr`
+ `year` `y` `yr`
**Topics**
+ [Visualizzazione dei dati di serie temporali](#CWL_Insights-Visualizing-TimeSeries)
+ [Visualizzazione dei dati di log raggruppati per campi](#CWL_Insights-Visualizing-ByFields)
+ [Utilizzo di più comandi stats in un'unica query](#CWL_QuerySyntax-stats-multi)
+ [Funzioni da utilizzare con le statistiche](#CWL_QuerySyntax-stats-functions)
## Visualizzazione dei dati di serie temporali
Le visualizzazioni delle serie temporali funzionano per le query con le seguenti caratteristiche:
+ La query contiene una o più funzioni di aggregazione. Per ulteriori informazioni, consulta [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
+ La query utilizza la funzione `bin()` per raggruppare i dati di un campo.
Queste query possono produrre grafici a linee, grafici ad area in pila, grafici a barre e grafici a torta.
**Esempi**
Per un tutorial completo, consulta [Esercitazione: eseguire una query che produce una visualizzazione serie temporale](CWL_AnalyzeLogData_VisualizationQuery.md).
Di seguito sono riportati altri esempi di query che funzionano per la visualizzazione delle serie temporali.
La seguente query genera una visualizzazione dei valori medi del campo `myfield1`, con un punto dati creato ogni cinque minuti. Ogni punto dati è l'aggregazione delle medie dei valori `myfield1` dei log dei cinque minuti precedenti.
```
stats avg(myfield1) by bin(5m)
```
La seguente query genera una visualizzazione di tre valori basati su campi diversi, con un punto dati creato ogni cinque minuti. La visualizzazione viene generata perché la query contiene funzioni di aggregazione e usa `bin()` come campo di raggruppamento.
```
stats avg(myfield1), min(myfield2), max(myfield3) by bin(5m)
```
**Restrizioni del grafico a linee e del grafico ad area in pila**
Le query che aggregano le informazioni sulle voci di log, ma non utilizzano la funzione `bin()`, possono generare grafici a barre. Tuttavia, le query non possono generare grafici a linee o grafici ad area in pila. Per ulteriori informazioni su questi tipi di query, consulta [Visualizzazione dei dati di log raggruppati per campi](#CWL_Insights-Visualizing-ByFields).
## Visualizzazione dei dati di log raggruppati per campi
È possibile produrre grafici a barre per le query che utilizzano la funzione `stats` e una o più funzioni di aggregazione. Per ulteriori informazioni, consulta [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
Per visualizzare la visualizzazione, eseguire la query. Quindi scegliere la scheda **Visualization (Visualizzazione)** selezionare la freccia accanto a **Linea (Linea)**, e scegliere **Bar (barra)**. Le visualizzazioni sono limitate a un massimo di 100 barre nel grafico a barre.
**Esempi**
Per un tutorial completo, consulta [Esercitazione: eseguire una query che produce una visualizzazione raggruppata per campi di log](CWL_AnalyzeLogData_VisualizationFieldQuery.md). I paragrafi seguenti includono ulteriori query di esempio per la visualizzazione in base ai campi.
La seguente query di log di flusso VPC trova il numero medio di byte trasferiti per sessione per ogni indirizzo di destinazione.
```
stats avg(bytes) by dstAddr
```
È inoltre possibile produrre un grafico che include più di una barra per ogni valore risultante. Ad esempio, la query del log di flusso VPC seguente trova il numero medio e massimo di byte trasferiti per sessione per ogni indirizzo di destinazione.
```
stats avg(bytes), max(bytes) by dstAddr
```
La query seguente trova il numero di registro di query Amazon Route 53 per ogni tipo di query.
```
stats count(*) by queryType
```
## Utilizzo di più comandi stats in un'unica query
È possibile utilizzare fino a due comandi `stats` in un'unica query. Ciò consente di eseguire un'aggregazione aggiuntiva sull'output della prima aggregazione.
**Esempio: interrogazione con due comandi `stats`**
Ad esempio, la seguente query trova innanzitutto il volume di traffico totale in contenitori da 5 minuti, quindi calcola il volume di traffico più alto, più basso e medio tra questi contenitori da 5 minuti.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length)/1024/1024 as logs_mb BY bin(5m)
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb
```
**Esempio: combinazione di più comandi stats con altre funzioni come `filter`, `fields` e `bin`**
È possibile combinare due comandi `stats` con altri comandi come `filter` e `fields` in un'unica query. Ad esempio, la seguente query trova il numero di indirizzi IP distinti nelle sessioni e trova il numero di sessioni per piattaforma client, filtra tali indirizzi IP e infine trova la media delle richieste di sessione per piattaforma client.
```
STATS count_distinct(client_ip) AS session_ips,
count(*) AS requests BY session_id, client_platform
| FILTER session_ips > 1
| STATS count(*) AS multiple_ip_sessions,
sum(requests) / count(*) AS avg_session_requests BY client_platform
```
È possibile utilizzare le funzioni `bin` e `dateceil` nelle query con più comandi `stats`. Ad esempio, la seguente query combina prima i messaggi in blocchi da 5 minuti, quindi aggrega i blocchi da 5 minuti in blocchi da 10 minuti e calcola i volumi di traffico più alti, più bassi e medi all'interno di ogni blocco di 10 minuti.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) / 1024 / 1024 AS logs_mb BY BIN(5m) as @t
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb BY dateceil(@t, 10m)
```
**Note e limitazioni**
Una query può avere al massimo due comandi `stats`. Questa quota non può essere modificata.
Se si utilizza un comando `sort` o `limit`, questo deve apparire dopo il secondo comando `stats`. Se è precedente al secondo comando `stats`, la query non è valida.
Quando una query ha due comandi `stats`, i risultati parziali della query non iniziano a essere visualizzati fino al completamento della prima aggregazione `stats`.
Nel secondo comando `stats` di un'unica query, è possibile fare riferimento solo ai campi definiti nel primo comando `stats`. Ad esempio, la seguente query non è valida perché il campo `@message` non sarà disponibile dopo la prima aggregazione `stats`.
```
FIELDS @message
| STATS SUM(Fault) by Operation
# You can only reference `SUM(Fault)` or Operation at this point
| STATS MAX(strlen(@message)) AS MaxMessageSize # Invalid reference to @message
```
Tutti i campi a cui si fa riferimento dopo il primo comando `stats` devono essere definiti in tale primo comando `stats`.
```
STATS sum(x) as sum_x by y, z
| STATS max(sum_x) as max_x by z
# You can only reference `max(sum_x)`, max_x or z at this point
```
**Importante**
La funzione `bin` utilizza sempre implicitamente il campo `@timestamp`. Ciò significa che non è possibile utilizzare `bin` nel secondo comando `stats` senza utilizzare il primo comando `stats` per propagare il campo `timestamp`. Ad esempio, la query seguente non è valida.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes BY @logStream
| STATS avg(ingested_bytes) BY bin(5m) # Invalid reference to @timestamp field
```
Definisci invece il campo `@timestamp` nel primo comando `stats`, quindi potrai utilizzarlo con `dateceil` nel secondo comando `stats`, come nell'esempio seguente.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes, max(@timestamp) as @t BY @logStream
| STATS avg(ingested_bytes) BY dateceil(@t, 5m)
```
## Funzioni da utilizzare con le statistiche
CloudWatch Logs Insights supporta sia le funzioni di aggregazione delle statistiche che le funzioni non di aggregazione delle statistiche.
Utilizza funzioni di aggregazione delle statistiche nel comando `stats` e come argomenti per altre funzioni.
| Funzione | Tipo di risultato | Description |
| --- | --- | --- |
| `avg(fieldName: NumericLogField)` | numero | La media dei valori nel campo specificato. |
| `count()` `count(fieldName: LogField)` | numero | Conta i log eventi. `count()` (o `count(*)`) conta tutti gli eventi restituiti dalla query, mentre `count(fieldName)` conta tutti i registri che includono il nome di campo specificato. |
| `count_distinct(fieldName: LogField)` | numero | Restituisce il numero di valori univoci per il campo. Se il campo dispone di alta cardinalità (contiene molti valori univoci), il valore restituito da `count_distinct` è solo un'approssimazione. |
| `max(fieldName: LogField)` | LogFieldValue | Il numero massimo di valori per questo campo di log nei log di query. |
| `min(fieldName: LogField)` | LogFieldValue | Il numero minimo di valori per questo campo di log nei log di query. |
| `pct(fieldName: LogFieldValue, percent: number)` | LogFieldValue | Un percentile indica lo stato relativo di un valore in un set di dati. Ad esempio, `pct(@duration, 95)` restituisce il valore `@duration` a cui il 95% dei valori di `@duration` sono inferiori a questo valore e il 5% sono superiori a questo valore. |
| `stddev(fieldName: NumericLogField)` | numero | La deviazione standard dei valori nel campo specificato. |
| `sum(fieldName: NumericLogField)` | numero | La somma dei valori nel campo specificato. |
**Funzioni di non aggregazione delle statistiche**
Utilizza funzioni di non aggregazione nel comando `stats` e come argomenti per altre funzioni.
| Funzione | Tipo di risultato | Description |
| --- | --- | --- |
| `earliest(fieldName: LogField)` | LogField | Restituisce il valore di `fieldName` dal log eventi con il timestamp meno recente nei log oggetto della query. |
| `latest(fieldName: LogField)` | LogField | Restituisce il valore di `fieldName` dal log eventi con il timestamp più recente nei log oggetto della query. |
| `sortsFirst(fieldName: LogField)` | LogField | Restituisce il valore di `fieldName` che occupa la prima posizione dell'ordine nei log oggetto della query. |
| `sortsLast(fieldName: LogField)` | LogField | Restituisce il valore di `fieldName` che occupa l'ultima posizione dell'ordine nei log oggetto della query. |
# limit
Utilizza `limit` per specificare il numero di log eventi che la query deve restituire. Se si omette`limit`, la query restituirà fino a 10.000 eventi di registro nei risultati.
L'esempio seguente restituisce solo i 25 log eventi più recenti
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
# dedup
Utilizza `dedup` per rimuovere i risultati duplicati in base a valori specifici nei campi indicati. Puoi utilizzare `dedup` con uno o più campi. Se specifichi un campo con `dedup`, viene restituito un solo log eventi per ogni valore univoco di tale campo. Se specifichi più campi, viene restituito un log eventi per ogni combinazione univoca di valori per tali campi.
I duplicati vengono eliminati in base al criterio di ordinamento, conservando solo il primo risultato dell'ordinamento. Ti consigliamo di ordinare i risultati prima di sottoporli al comando `dedup`. Se i risultati non vengono ordinati prima di essere sottoposti a `dedup`, viene utilizzato l'ordinamento decrescente predefinito tramite `@timestamp`.
I valori nulli non sono considerati duplicati per la valutazione. I log eventi con valori nulli per uno qualsiasi dei campi specificati vengono conservati. Per eliminare i campi con valori nulli, utilizza **`filter`** tramite la funzione `isPresent(field)`.
L'unico comando di query che puoi utilizzare in una query dopo il comando `dedup` è `limit`.
Quando si utilizza `dedup` in una query, la console visualizza un messaggio come **Mostra X di record Y, dove X** è il numero di risultati deduplicati e Y è il numero totale di record corrispondenti prima della deduplicazione. Ciò indica che i record duplicati sono stati rimossi e non significa che mancano dati.
**Esempio: visualizza solo il log eventi più recente per ogni valore univoco del campo denominato `server`**
L'esempio seguente mostra i campi `timestamp`, `server`, `severity` e `message` solo per l'evento più recente per ogni valore univoco di `server`.
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server
```
Per altri esempi di query di CloudWatch Logs Insights, consulta. [Query generali](CWL_QuerySyntax-examples.md#CWL_QuerySyntax-examples-general)
# unmask
Utilizza `unmask` per visualizzare tutto il contenuto di un log eventi nel quale alcuni contenuti sono mascherati a causa di una policy di protezione dei dati. Per eseguire questo comando, è necessario disporre dell'autorizzazione `logs:Unmask`.
Per ulteriori informazioni sulla protezione dei dati nei gruppi di log, consulta la sezione [Incremento della protezione dei dati di log sensibili con il mascheramento](mask-sensitive-log-data.md).
# unnest
Si usa `unnest` per appiattire un elenco preso come input per produrre più record con un singolo record per ogni elemento dell'elenco. In base al numero di elementi contenuti in un campo, questo comando elimina il record corrente e genera nuovi record. Ogni record include il`unnested_field`, che rappresenta un elemento. Tutti gli altri campi provengono dal record originale.
L'input per `unnest` è`LIST`, che proviene dalla `jsonParse` funzione. Per ulteriori informazioni, vedere [Tipi di struttura](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html#CWL_QuerySyntax-structure-types). Qualsiasi altro tipo, ad esempio `String` e `MAP``numbers`, viene considerato come un elenco contenente un elemento`unnest`.
**Struttura di comando**
L'esempio seguente descrive il formato di questo comando.
```
unnest field into unnested_field
```
**Query di esempio**
L'esempio seguente analizza una stringa di oggetto JSON ed espande un elenco di eventi di campo.
```
fields jsonParse(@message) as json_message
| unnest json_message.events into event
| display event.name
```
L'evento di registro per questa query di esempio potrebbe essere una stringa JSON come segue:
```
{
"events": [
{
"name": "exception"
},
{
"name": "user action"
}
]
}
```
In questo caso, la query di esempio produce due record nel risultato della query, uno con `event.name` as `exception` e l'altro con `event.name` un'azione **utente**
**Query di esempio**
L'esempio seguente appiattisce un elenco e quindi filtra gli elementi.
```
fields jsonParse(@message) as js
| unnest js.accounts into account
| filter account.type = "internal"
```
**Query di esempio**
L'esempio seguente appiattisce un elenco per l'aggregazione.
```
fields jsonParse(trimmedData) as accounts
| unnest accounts into account
| stats sum(account.droppedSpans) as n by account.accountId
| sort n desc
| limit 10
```
# cercare
`lookup`Da utilizzare per arricchire i risultati della query con i dati di riferimento di una tabella di ricerca. Una tabella di ricerca contiene dati CSV che carichi su Amazon CloudWatch Logs. Quando viene eseguita una query, il `lookup` comando confronta un campo nei tuoi eventi di registro con un campo nella tabella di ricerca e aggiunge i campi di output specificati ai risultati.
Utilizza le tabelle di ricerca per scenari di arricchimento dei dati, ad esempio la mappatura dei dettagli IDs da utente a utente, dei codici prodotto alle informazioni sul prodotto o dei codici di errore alle descrizioni degli errori.
## Creazione e gestione di tabelle di ricerca
Prima di poter utilizzare il `lookup` comando in una query, è necessario creare una tabella di ricerca. Puoi creare e gestire tabelle di ricerca dalla CloudWatch console o utilizzando l'API Amazon CloudWatch Logs.
**Per creare una tabella di ricerca (console)**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel riquadro di navigazione, scegli **Impostazioni**, quindi scegli la scheda **Registri.**
1. **Scorri **fino alle tabelle di ricerca** e scegli Gestisci.**
1. Scegli **Crea tabella di ricerca.**
1. Inserisci un nome per la tabella di ricerca. Il nome può contenere solo caratteri alfanumerici, trattini e caratteri di sottolineatura.
1. (Opzionale) Immettere una descrizione.
1. Carica un file CSV. Il file deve includere una riga di intestazione con i nomi delle colonne, utilizzare la codifica UTF-8 e non superare i 10 MB.
1. (Facoltativo) Specificate una AWS KMS chiave per crittografare i dati della tabella.
1. Scegli **Create** (Crea).
Dopo aver creato una tabella di ricerca, è possibile visualizzarla nell'editor di query di CloudWatch Logs Insights. Scegli la scheda **Tabelle di ricerca** per sfogliare le tabelle disponibili e i relativi campi.
**Per aggiornare una tabella di ricerca, seleziona la tabella e scegli **Azioni**, Aggiorna.** Carica un nuovo file CSV per sostituire tutto il contenuto esistente. **Per eliminare una tabella di ricerca, scegli **Azioni**, Elimina.**
**Nota**
È possibile creare fino a 100 tabelle di ricerca per account. Regione AWS I file CSV possono pesare fino a 10 MB. Puoi anche gestire le tabelle di ricerca utilizzando l'API Amazon CloudWatch Logs. Per ulteriori informazioni, [CreateLookupTable](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLookupTable.html)consulta *Amazon CloudWatch Logs API Reference.*
**Nota**
Se la tabella di ricerca è crittografata con una chiave KMS, il chiamante deve disporre dell'`kms:Decrypt`autorizzazione sulla chiave (la chiave KMS utilizzata per crittografare la tabella di ricerca) per utilizzare l'`StartQuery`API con una query che faccia riferimento a tale tabella di ricerca. Per ulteriori informazioni, consulta [Crittografa le tabelle di ricerca nei CloudWatch registri utilizzando AWS Key Management Service](encrypt-lookup-tables-kms.md).
## Sintassi delle query per la ricerca
**Struttura di comando**
Di seguito viene illustrato il formato di questo comando.
```
lookup table lookup-field as log-field [,...] output-mode output-field[,...]
```
Il comando utilizza i seguenti argomenti:
+ `table`— Il nome della tabella di ricerca da utilizzare.
+ `lookup-field`— Il campo nella tabella di ricerca con cui confrontare.
+ `log-field`— Il campo del registro degli eventi da abbinare. La corrispondenza è esatta e fa distinzione tra maiuscole e minuscole.
+ `output-mode`— `OUTPUT` Specificare di aggiungere i campi di output ai risultati. Se un campo con lo stesso nome esiste già nell'evento di registro, viene sovrascritto.
+ `output-field`— Uno o più campi della tabella di ricerca da aggiungere ai risultati.
**Esempio: arricchire gli eventi del registro con i dettagli dell'utente**
Supponiamo di avere un gruppo di log con eventi che contengono un `id` campo e una tabella di ricerca denominata `user_data` con colonne`id`,`name`, `email` e. `department` La seguente query arricchisce ogni evento di registro con il nome, l'e-mail e il reparto dell'utente presenti nella tabella di ricerca.
```
fields action, status, name, email, department
| lookup user_data id OUTPUT name, email, department
```
**Esempio: utilizzare la ricerca con l'aggregazione**
È possibile utilizzare i campi di output di ricerca con funzioni di aggregazione. La seguente query arricchisce gli eventi di registro con i dettagli dell'utente e quindi conta gli eventi raggruppati per indirizzo e-mail.
```
fields user_id, action, username, email, department
| lookup user_data user_id OUTPUT username, email, department
| stats count(*) by email
```
**Esempio: utilizzare la ricerca con filtro**
È possibile filtrare i risultati in base ai campi restituiti dalla ricerca. La seguente query arricchisce gli eventi di registro e quindi filtra per mostrare solo gli eventi di un reparto specifico.
```
fields user_id, action
| lookup user_data user_id OUTPUT username, email, department
| filter department = "Engineering"
```
# Funzioni booleane, di confronto, numeriche, datetime e altre
CloudWatch Logs Insights supporta molte altre operazioni e funzioni nelle query, come spiegato nelle sezioni seguenti.
**Topics**
+ [Operatori aritmetici](#CWL_QuerySyntax-operations-arithmetic)
+ [Operatori booleani](#CWL_QuerySyntax-operations-Boolean)
+ [Operatori di confronto](#CWL_QuerySyntax-operations-comparison)
+ [Operatori numerici](#CWL_QuerySyntax-operations-numeric)
+ [Tipi di struttura](#CWL_QuerySyntax-structure-types)
+ [Funzioni DateTime](#CWL_QuerySyntax-datetime)
+ [Funzioni generali](#CWL_QuerySyntax-general-functions)
+ [Funzioni JSON](#CWL_QuerySyntax-json-functions)
+ [Funzioni della stringa di indirizzi IP](#CWL_QuerySyntax-IPaddress-functions)
+ [Funzioni stringa](#CWL_QuerySyntax-string-functions)
## Operatori aritmetici
Le operazioni aritmetiche accettano tipi di dati numerici come argomenti e restituiscono risultati numerici. Puoi utilizzare operazioni aritmetiche nei comandi `filter` e `fields` e come argomenti per altre funzioni.
| Operation | Description |
| --- | --- |
| `a + b` | Addizione |
| `a - b` | Sottrazione |
| `a * b` | Moltiplicazione |
| `a / b` | Divisione |
| `a ^ b` | Elevamento a potenza (`2 ^ 3` restituisce `8`) |
| `a % b` | Resto o modulo (`10 % 3` restituisce `1`) |
## Operatori booleani
Utilizza gli operatori booleani `and`, `or` e `not`.
**Nota**
Utilizza gli operatori booleani solo nelle funzioni che restituiscono un valore **TRUE** o **FALSE**.
## Operatori di confronto
Le operazioni di confronto accettano tutti i tipi di dati come argomenti e restituiscono un risultato booleano. Utilizza operazioni di confronto nel comando `filter` e come argomenti per altre funzioni.
| Operatore | Description |
| --- | --- |
| `=` | Uguale |
| `!=` | Non uguale |
| `<` | Minore di |
| `>` | Maggiore di |
| `<=` | Minore o uguale a |
| `>=` | Maggiore o uguale a |
## Operatori numerici
Le operazioni numeriche accettano tipi di dati numerici come argomenti e restituiscono risultati numerici. Utilizza operazioni aritmetiche nei comandi `filter` e `fields`, oltre che come argomenti per altre funzioni.
| Operation | Tipo di risultato | Description |
| --- | --- | --- |
| `abs(a: number)` | numero | Valore assoluto |
| `ceil(a: number)` | numero | Arrotonda per eccesso (l'intero più piccolo che è maggiore del valore di `a`) |
| `floor(a: number)` | numero | Arrotonda per difetto (l'intero più grande che è minore del valore di `a`) |
| `greatest(a: number, ...numbers: number[])` | numero | Restituisce il valore più grande |
| `least(a: number, ...numbers: number[])` | numero | Restituisce il valore di piccolo |
| `log(a: number)` | numero | Log naturale |
| `sqrt(a: number)` | numero | Radice quadrata |
## Tipi di struttura
Una mappa o un elenco è un tipo di struttura in CloudWatch Logs Insights che consente di accedere e utilizzare gli attributi per le query.
**Esempio: per ottenere una mappa o un elenco**
`jsonParse`Utilizzalo per analizzare un campo che è una stringa json in una mappa o in un elenco.
```
fields jsonParse(@message) as json_message
```
**Esempio: per accedere agli attributi**
Utilizza l'operatore dot access (map.attribute) per accedere agli elementi in una mappa. Se un attributo in una mappa contiene caratteri speciali, usa i backtick per racchiudere il nome dell'attributo (map.attributes). `special.char`).
```
fields jsonParse(@message) as json_message
| stats count() by json_message.status_code
```
Usa l'operatore di accesso tra parentesi (list [index]) per recuperare un elemento in una posizione specifica all'interno dell'elenco.
```
fields jsonParse(@message) as json_message
| filter json_message.users[1].action = "PutData"
```
Se nel nome della chiave sono presenti caratteri speciali, racchiudi i caratteri speciali nei backtick (``).
```
fields jsonParse(@message) as json_message
| filter json_message.`user.id` = "123"
```
**Esempio: risultati vuoti**
Le mappe e gli elenchi vengono considerati nulli per le funzioni di tipo stringa, numerico e datetime.
```
fields jsonParse(@message) as json_message
| display toupper(json_message)
```
Il risultato del confronto della mappa e dell'elenco con qualsiasi altro campo risulta. `false`
**Nota**
L'utilizzo di map and list in `dedup``pattern`,`sort`, e `stats` non è supportato.
## Funzioni DateTime
**Funzioni DateTime**
Utilizza le funzioni datetime nei comandi `fields` e `filter` e come argomenti per altre funzioni. Utilizza queste funzioni per creare bucket temporali per le query con funzioni di aggregazione. Utilizza periodi di tempo composti da un numero e da uno dei seguenti:
+ `ms`per millisecondi
+ `s`per secondi
+ `m`per minuti
+ `h`per ore
Ad esempio, `10m` è 10 minuti e `1h` è un'ora.
**Nota**
Usa l'unità di tempo più appropriata per la tua funzione datetime. CloudWatch Logs limita la richiesta in base all'unità di tempo scelta. Ad esempio, limita 60 come valore massimo per qualsiasi richiesta che utilizza. `s` Quindi, se si specifica`bin(300s)`, CloudWatch Logs lo implementa effettivamente come 60 secondi, poiché 60 è il numero di secondi in un minuto, quindi CloudWatch Logs non utilizzerà un numero superiore a 60 con. `s` Per creare un bucket da 5 minuti, usa invece. `bin(5m)`
Il limite di `ms` è 1000, i cappucci di `s` e `m` sono 60 e il limite di `h` è 24.
La tabella seguente contiene un elenco delle diverse funzioni datetime che è possibile utilizzare nei comandi di query. La tabella elenca il tipo di risultato di ciascuna funzione e contiene una descrizione di ciascuna funzione.
**Suggerimento**
Quando crei un comando di query, puoi utilizzare il selettore temporale per selezionare un periodo di tempo per il quale desideri eseguire query. Ad esempio, puoi impostare un periodo di tempo con intervalli di 5 e 30 minuti, intervalli di 1, 3 e 12 ore oppure un intervallo di tempo personalizzato. Puoi anche impostare periodi di tempo tra date specifiche.
| Funzione | Tipo di risultato | Description |
| --- | --- | --- |
| `bin(period: Period)` | Time stamp | Arrotonda il valore di `@timestamp` al periodo di tempo specificato per poi troncarlo. Ad esempio, `bin(5m)` arrotonda il valore `@timestamp` ai 5 minuti più vicini. È possibile utilizzarlo per raggruppare più voci di log in un'interrogazione. L'esempio seguente restituisce il numero di eccezioni all'ora: filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
La funzione `bin` supporta le seguenti abbreviazioni e unità di tempo. Per tutte le unità e le abbreviazioni che includono più di un carattere, è supportata l'aggiunta di s per il plurale. Quindi entrambi `hr` e `hrs` lavorano per specificare gli orari. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html) |
| `datefloor(timestamp: Timestamp, period: Period)` | Time stamp | Tronca il time stamp al periodo specificato. Ad esempio, `datefloor(@timestamp, 1h)` tronca tutti i valori di `@timestamp` alla mezzora. |
| `dateceil(timestamp: Timestamp, period: Period)` | Time stamp | Arrotonda il time stamp al periodo specificato e quindi tronca. Ad esempio, `dateceil(@timestamp, 1h)` tronca tutti i valori di `@timestamp` all'inizio di ogni ora. |
| `fromMillis(fieldName: number)` | Time stamp | Interpreta il campo di input come il numero di millisecondi dall'epoca Unix e lo converte in un timestamp. |
| `toMillis(fieldName: Timestamp)` | numero | Converte il timestamp trovato nel campo denominato in un numero che rappresenta i millisecondi dall'epoca di Unix. Ad esempio, `toMillis(@timestamp)` converte il timestamp `2022-01-14T13:18:031.000-08:00` in `1642195111000`. |
| `now()` | numero | Restituisce l'ora in cui è stata avviata l'elaborazione della query, in secondi epocali. Questa funzione non accetta argomenti. È possibile utilizzarla per filtrare i risultati della query in base all'ora corrente. Ad esempio, la seguente query restituisce tutti gli errori 4xx delle ultime due ore: parse @message "Status Code: *;" as statusCode\n
| filter statusCode >= 400 and statusCode <= 499 \n
| filter toMillis(@timestamp) >= (now() * 1000 - 7200000)
L'esempio seguente restituisce tutte le voci di registro delle ultime cinque ore che contengono la parola `error` o `failure` fields @timestamp, @message
| filter @message like /(?i)(error|failure)/
| filter toMillis(@timestamp) >= (now() * 1000 - 18000000)
|
**Nota**
Attualmente, CloudWatch Logs Insights non supporta il filtraggio dei log con timestamp leggibili dall'uomo.
## Funzioni generali
**Funzioni generali**
Utilizza le funzioni generali nei comandi `fields` e `filter` e come argomenti per altre funzioni.
| Funzione | Tipo di risultato | Description |
| --- | --- | --- |
| `ispresent(fieldName: LogField)` | Booleano | Restituisce `true` se il campo esiste |
| `coalesce(fieldName: LogField, ...fieldNames: LogField[])` | LogField | Restituisce il primo valore non nullo dall'elenco. |
## Funzioni JSON
**Funzioni JSON**
Usa le funzioni JSON nei `filter` comandi `fields` and e come argomenti per altre funzioni.
| Funzione | Tipo di risultato | Description |
| --- | --- | --- |
| `jsonParse(fieldName: string)` | Mappa \$1 Elenco \$1 Vuoto | Restituisce una mappa o un elenco quando l'input è una rappresentazione in formato stringa di un oggetto JSON o di un array JSON. Restituisce un valore vuoto, se l'input non è una delle rappresentazioni. |
| `jsonStringify(fieldName: Map \| List)` | Stringa | Restituisce una stringa JSON da una mappa o da un elenco di dati. |
## Funzioni della stringa di indirizzi IP
**Funzioni della stringa di indirizzi IP**
Utilizza le funzioni stringa per gli indirizzi IP nei comandi `filter` e `fields`, oltre che come argomenti per altre funzioni.
| Funzione | Tipo di risultato | Description |
| --- | --- | --- |
| `isValidIp(fieldName: string)` | booleano | Restituisce `true` se il campo è un IPv6 indirizzo IPv4 o valido. |
| `isValidIpV4(fieldName: string)` | booleano | Restituisce `true` se il campo è un IPv4 indirizzo valido. |
| `isValidIpV6(fieldName: string)` | booleano | Restituisce `true` se il campo è un IPv6 indirizzo valido. |
| `isIpInSubnet(fieldName: string, subnet: string)` | booleano | Restituisce `true` se il campo è un IPv6 indirizzo IPv4 or valido all'interno della sottorete v4 o v6 specificata. Quando si specifica la sottorete, utilizzare la notazione CIDR, come `192.0.2.0/24` o `2001:db8::/32`, dove `192.0.2.0` o `2001:db8::` è l'inizio del blocco CIDR. |
| `isIpv4InSubnet(fieldName: string, subnet: string)` | booleano | Restituisce `true` se il campo è un IPv4 indirizzo valido all'interno della sottorete v4 specificata. Quando si specifica la sottorete, utilizzare la notazione CIDR, come `192.0.2.0/24`, dove `192.0.2.0` è l'inizio del blocco CIDR. |
| `isIpv6InSubnet(fieldName: string, subnet: string)` | booleano | Restituisce `true` se il campo è un IPv6 indirizzo valido all'interno della sottorete v6 specificata. Quando si specifica la sottorete, utilizzare la notazione CIDR, come `2001:db8::/32`, dove `2001:db8::` è l'inizio del blocco CIDR. |
## Funzioni stringa
**Funzioni stringa**
Utilizza le funzioni stringa nei comandi `fields` e `filter`, oltre che come argomenti per altre funzioni.
| Funzione | Tipo di risultato | Description |
| --- | --- | --- |
| `isempty(fieldName: string)` | Numero | Restituisce `1` se il campo manca o è una stringa vuota. |
| `isblank(fieldName: string)` | Numero | Restituisce `1` se il campo manca, è una stringa vuota o contiene solo spazi vuoti. |
| `concat(str: string, ...strings: string[])` | stringa | Concatena le stringhe. |
| `ltrim(str: string)` `ltrim(str: string, trimChars: string)` | stringa | Se la funzione non dispone di un secondo argomento, rimuove gli spazi vuoti dalla sinistra della stringa. Se la funzione dispone di un secondo argomento stringa, non rimuove gli spazi vuoti. Invece, rimuove i caratteri in `trimChars` dalla sinistra di `str`. Ad esempio, `ltrim("xyZxyfooxyZ","xyZ")` restituisce `"fooxyZ"`. |
| `rtrim(str: string)` `rtrim(str: string, trimChars: string)` | stringa | Se la funzione dispone di un secondo argomento stringa, rimuove gli spazi vuoti dalla destra della stringa. Se la funzione dispone di un secondo argomento stringa, non rimuove gli spazi vuoti. Invece, rimuove i caratteri di `trimChars` dalla destra di `str`. Ad esempio, `rtrim("xyZfooxyxyZ","xyZ")` restituisce `"xyZfoo"`. |
| `trim(str: string)` `trim(str: string, trimChars: string)` | stringa | Se la funzione dispone di un secondo argomento, rimuove gli spazi vuoti da entrambe le estremità della stringa. Se la funzione dispone di un secondo argomento stringa, non rimuove gli spazi vuoti. Invece, rimuove i caratteri di `trimChars` da entrambi i lati di `str`. Ad esempio, `trim("xyZxyfooxyxyZ","xyZ")` restituisce `"foo"`. |
| `strlen(str: string)` | numero | Restituisce la lunghezza della stringa in punti di codice Unicode. |
| `toupper(str: string)` | stringa | Converte la stringa in maiuscolo. |
| `tolower(str: string)` | stringa | Converte la stringa in minuscolo. |
| `substr(str: string, startIndex: number)` `substr(str: string, startIndex: number, length: number)` | stringa | Restituisce una sottostringa partendo dall'indice specificato dall'argomento numero fino alla fine della stringa. Se la funzione dispone di un secondo argomento numero, contiene la lunghezza della sottostringa da recuperare. Ad esempio, `substr("xyZfooxyZ",3, 3)` restituisce `"foo"`. |
| `replace(fieldName: string, searchValue: string, replaceValue: string)` | stringa | Sostituisce tutte le istanze di `searchValue` in `fieldName: string` con `replaceValue`. Ad esempio, la funzione `replace(logGroup,"smoke_test","Smoke")` cerca log eventi in cui il campo `logGroup` contiene il valore della stringa `smoke_test` e sostituisce il valore con la stringa `Smoke`. |
| `strcontains(str: string, searchValue: string)` | numero | Restituisce 1 se `str` contiene `searchValue` e 0 in caso contrario. |
# Campi che contengono caratteri speciali
Se un campo contiene caratteri non alfanumerici diversi dal `@` simbolo o dal punto (`.`), è necessario circondare il campo con caratteri di contrassegno (). ``` Ad esempio, il campo di log `foo-bar` deve essere racchiuso tra caratteri apice inverso (``foo-bar``) perché contiene un carattere non alfanumerico, ossia il trattino (`-`).
# Utilizzo di alias e commenti nelle query
Crea query che contengono alias. Utilizza gli alias per rinominare i campi di log o per estrarre valori nei campi. Usa la parola chiave `as` per assegnare un alias a un campo di log o un risultato. Puoi utilizzare più alias in una query. Puoi utilizzare gli alias nei seguenti comandi:
+ `fields`
+ `parse`
+ `sort`
+ ` stats `
Negli esempi seguenti viene illustrato come creare query che contengono alias.
**Esempio**
La query contiene un alias nel comando `fields`.
```
fields @timestamp, @message, accountId as ID
| sort @timestamp desc
| limit 20
```
La query restituisce i valori per i campi `@timestamp`, `@message` e `accountId`. I risultati sono ordinati in ordine decrescente e sono limitati a 20. I valori per `accountId` sono elencati sotto l'alias `ID`.
**Esempio**
La query contiene alias nei comandi `sort` e `stats`.
```
stats count(*) by duration as time
| sort time desc
```
La query conta il numero di volte che il campo `duration`è presente nel gruppo di log e ordina i risultati in ordine decrescente. I valori per `duration` sono elencati sotto l'alias `time`.
## Utilizzo di commenti
CloudWatch Logs Insights supporta i commenti nelle query. Utilizza il carattere cancelletto (**\$1**) per impostare i commenti. Puoi utilizzare i commenti per ignorare le righe nelle query o nelle query di documenti.
**Esempio: query**
Quando viene emessa la seguente query, la seconda riga viene ignorata.
```
fields @timestamp, @message, accountId
# | filter accountId not like "7983124201998"
| sort @timestamp desc
| limit 20
```
# Inizia a usare Logs Insights QL: tutorial sulle query
Le sezioni seguenti includono esempi di tutorial sulle query per aiutarti a iniziare a usare Logs Insights QL.
**Topics**
+ [Tutorial: esecuzione e modifica di una query di esempio](CWL_AnalyzeLogData_RunSampleQuery.md)
+ [Tutorial: esecuzione di una query con una funzione di aggregazione](CWL_AnalyzeLogData_AggregationQuery.md)
+ [Esercitazione: eseguire una query che produce una visualizzazione raggruppata per campi di log](CWL_AnalyzeLogData_VisualizationFieldQuery.md)
+ [Esercitazione: eseguire una query che produce una visualizzazione serie temporale](CWL_AnalyzeLogData_VisualizationQuery.md)
# Tutorial: esecuzione e modifica di una query di esempio
Il seguente tutorial ti aiuta a iniziare a usare Logs Insights. CloudWatch Esegui una query di esempio in Logs Insights QL, quindi scopri come modificarla ed eseguirla nuovamente.
Per eseguire una query, è necessario che i log siano già archiviati in Logs. CloudWatch Se stai già utilizzando CloudWatch Logs e hai configurato gruppi di log e flussi di log, sei pronto per iniziare. Potresti anche avere già dei log se utilizzi servizi come AWS CloudTrail Amazon Route 53 o Amazon VPC e hai configurato i log di tali servizi in modo che vadano a Logs. CloudWatch Per ulteriori informazioni sull'invio di log a Logs, consulta. CloudWatch [Guida introduttiva ai CloudWatch registri](CWL_GettingStarted.md)
Le query in CloudWatch Logs Insights restituiscono un insieme di campi degli eventi di registro o il risultato di un'aggregazione matematica o di un'altra operazione eseguita sugli eventi di registro. Questo tutorial illustra una query che restituisce un elenco di eventi di log.
## Esecuzione di una query di esempio
**Per eseguire una query di esempio di Logs CloudWatch Insights**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione scegli **Logs** (Registri), quindi **Logs Insights**.
Nella pagina **Logs Insights**, l'editor di query contiene una query predefinita in Logs Insights QL che restituisce i 20 eventi di registro più recenti.
1. Nell'elenco a discesa **Select log group(s)** (Seleziona uno o più gruppi di log), scegli uno o più gruppi di log su cui eseguire query.
Se si tratta di un account di monitoraggio in modalità CloudWatch osservabile tra più account, è possibile selezionare gruppi di log negli account di origine e nell'account di monitoraggio. Una singola query può interrogare i log di diversi account contemporaneamente.
È possibile filtrare i gruppi di log in base al nome del gruppo di log, all'ID account o all'etichetta dell'account.
Quando si seleziona un gruppo di log nella classe di log Standard, CloudWatch Logs Insights rileva automaticamente i campi di dati nel gruppo. Per visualizzare i campi individuati, seleziona il menu **Fields** (Campi) in alto a destra nella pagina.
**Nota**
I campi rilevati sono supportati solo per i gruppi di log nella classe di log Standard. Per ulteriori informazioni sulle classi di log, vedere[Classi di registro](CloudWatch_Logs_Log_Classes.md).
1. (Facoltativo) Utilizza il selettore temporale per selezionare un periodo di tempo per il quale desideri eseguire query.
Puoi scegliere tra intervalli di 5 e 30 minuti, intervalli di 1, 3 e 12 ore oppure un intervallo di tempo personalizzato.
1. Scegli **Run** (Esegui) per visualizzare i risultati.
Per questo tutorial, i risultati includono i 20 log eventi aggiunti più di recente.
CloudWatch Logs visualizza un grafico a barre degli eventi di registro nel gruppo di log nel tempo. Questo grafico a barre mostra la distribuzione di eventi nel gruppo di log che corrisponde alla query e all'intervallo di tempo, non solo gli eventi visualizzati nella tabella.
1. Per visualizzare tutti i campi di un log eventi restituito, scegli l'icona triangolare del menu a discesa a sinistra dell'evento numerato.
## Modifica della query di esempio
In questo tutorial, viene modificata la query di esempio per mostrare gli ultimi 50 eventi di log.
Se non hai già eseguito il tutorial precedente, fallo ora. Questo tutorial inizia da dove il tutorial precedente è terminato.
**Nota**
Alcune query di esempio fornite con CloudWatch Logs Insights utilizzano i `tail` comandi `head` or invece di. `limit` Questi comandi sono obsoleti e sostituiti con `limit`. Utilizza `limit` invece di `head` o `tail` in tutte le query di tua creazione.
**Per modificare la query di esempio di CloudWatch Logs Insights**
1. Nell'editor di query, imposta il valore **20** su **50**, e quindi scegli **Run (Esegui)**.
Vengono visualizzati i risultati della nuova query. Ipotizzando che il gruppo di log contenga dati sufficienti nell'intervallo di tempo predefinito, sono ora elencati 50 eventi di log.
1. (Facoltativo) Puoi salvare le query create. Per salvare questa query, scegli **Save (Salva)**. Per ulteriori informazioni, consulta [Salva ed esegui nuovamente le query di Logs Insights CloudWatch](CWL_Insights-Saving-Queries.md).
## Aggiunta di un comando di filtro alla query di esempio
Questo tutorial mostra come apportare una modifica alla query nell'editor di query. In questo tutorial, i risultati della query precedente vengono filtrati in base a un campo negli eventi di log recuperati.
Se non hai già eseguito i tutorial precedenti, fallo in questo momento. Questo tutorial inizia da dove il tutorial precedente è terminato.
**Per aggiungere un comando di filtro alla query precedente**
1. Stabilisci quale campo filtrare. Per visualizzare i campi più comuni rilevati da CloudWatch Logs negli eventi di registro contenuti nei gruppi di log selezionati negli ultimi 15 minuti e la percentuale di tali eventi di registro in cui viene visualizzato ogni campo, seleziona **Campi** sul lato destro della pagina.
Per visualizzare i campi contenuti in un determinato log eventi, scegli l'icona a sinistra di tale riga.
Il campo **awsRegion** può essere visualizzato nel log eventi, a seconda degli eventi presenti nei log. Nel resto di questo tutorial, **awsRegion** viene utilizzato come campo di filtro, ma puoi utilizzarne uno diverso se tale campo non è disponibile.
1. Nella casella Editor di query, posiziona il cursore dopo **50** e premi Invio.
1. Nella nuova riga, digita innanzitutto \$1 (il carattere barra verticale) e uno spazio. I comandi in una query di CloudWatch Logs Insights devono essere separati dal carattere pipe.
1. Specificare **filter awsRegion="us-east-1"**.
1. Scegli **Esegui**.
La query viene eseguita nuovamente e mostra ora i 50 risultati più recenti che soddisfano il nuovo filtro.
Se il filtro è stato eseguito su un campo diverso e hai ricevuto un risultato di errore, potrebbe essere necessario applicare un carattere di escape al nome campo. Se il nome campo include caratteri non alfanumerici, è necessario inserire caratteri apice inverso (`) prima e dopo il nome del campo (ad esempio, **`error-code`="102"**).
È necessario utilizzare i caratteri di apice inverso per i nomi di campo che contengono caratteri non alfanumerici, ma non per i valori. I valori sono sempre contenuti tra virgolette (").
Logs Insights QL include potenti funzionalità di interrogazione, tra cui diversi comandi e supporto per espressioni regolari, operazioni matematiche e statistiche. Per ulteriori informazioni, consulta [CloudWatch Sintassi delle interrogazioni in linguaggio Logs Insights](CWL_QuerySyntax.md).
# Tutorial: esecuzione di una query con una funzione di aggregazione
Puoi utilizzare funzioni di aggregazione con il comando `stats` e come argomenti per altre funzioni. In questo tutorial, viene eseguito un comando di query che conta il numero di log eventi contenenti un campo specificato. Il comando di query restituisce un conteggio totale raggruppato in base al valore o ai valori del campo specificato. Per ulteriori informazioni sulle funzioni di aggregazione, consulta [Operazioni e funzioni supportate](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html#CWL_QuerySyntax-operations-functions) nella *Amazon CloudWatch Logs User Guide.*
**Esecuzione di una query con una funzione di aggregazione**
1. Apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel pannello di navigazione scegli **Logs** (Registri), quindi **Logs Insights**.
1. Conferma che la scheda **Logs Insights QL** sia selezionata.
1. Nell'elenco a discesa **Select log group(s)** (Seleziona uno o più gruppi di log), scegli uno o più gruppi di log su cui eseguire query.
Se si tratta di un account di monitoraggio in CloudWatch modalità osservabile su più account, è possibile selezionare gruppi di log negli account di origine e nell'account di monitoraggio. Una singola query può interrogare i log di diversi account contemporaneamente.
È possibile filtrare i gruppi di log in base al nome del gruppo di log, all'ID account o all'etichetta dell'account.
Quando si seleziona un gruppo di log, CloudWatch Logs Insights rileva automaticamente i campi di dati nel gruppo di log se si tratta di un gruppo di log di classe Standard. Per visualizzare i campi individuati, seleziona il menu **Fields** (Campi) in alto a destra nella pagina.
1. Elimina la query predefinita nell'editor di query e immetti il seguente comando:
```
stats count(*) by fieldName
```
1. Sostituisci *fieldName* con un campo rilevato dal menu **Campi**.
Il menu **Campi** si trova in alto a destra della pagina e mostra tutti i campi rilevati da CloudWatch Logs Insights nel gruppo di log.
1. Scegli **Run (Esegui)** per visualizzare i risultati della query.
I risultati della query mostrano il numero di record nel gruppo di log che corrispondono al comando di query e il conteggio totale raggruppato in base al valore o ai valori del campo specificato.
# Esercitazione: eseguire una query che produce una visualizzazione raggruppata per campi di log
Quando si esegue una query che utilizza la funzione `stats` per raggruppare i risultati restituiti in base ai valori di uno o più campi nelle voci del log, è possibile visualizzare i risultati come grafico a barre, grafico a torta, grafico a linee o grafico ad area in pila. In questo modo è possibile visualizzare in modo più efficiente le tendenze nei log.
**Per eseguire una query per la visualizzazione**
1. Apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel pannello di navigazione scegli **Logs** (Registri), quindi **Logs Insights**.
1. Nell'elenco a discesa **Select log group(s)** (Seleziona uno o più gruppi di registro), scegli uno o più gruppi di registro su cui eseguire query.
Se si tratta di un account di monitoraggio in CloudWatch modalità osservabile su più account, è possibile selezionare gruppi di log negli account di origine e nell'account di monitoraggio. Una singola query può interrogare i log di diversi account contemporaneamente.
È possibile filtrare i gruppi di log in base al nome del gruppo di log, all'ID account o all'etichetta dell'account.
1. Nell'editor di query, eliminare i contenuti correnti, immettere la funzione seguente `stats` quanto segue e scegliere **Run query (Esegui query)**.
```
stats count(*) by @logStream
| limit 100
```
I risultati mostrano il numero di eventi di log nel gruppo di log per ogni flusso di log. I risultati sono limitati a solo 100 righe.
1. Seleziona la scheda **Visualization (Visualizzazione)**.
1. Seleziona la freccia accanto a **Line (Linee)**, quindi scegli **Bar (Barre)**.
Viene visualizzato il grafico a barre, che mostra una barra per ogni flusso di log nel gruppo di log.
# Esercitazione: eseguire una query che produce una visualizzazione serie temporale
Quando esegui una query che utilizza la funzione `bin()` per raggruppare i risultati restituiti da un periodo di tempo, puoi visualizzare i risultati come un grafico a linee, grafico ad area in pila, grafico a torta o grafico a barre. Ciò consente di visualizzare in modo più efficace le tendenze nei log eventi nel tempo.
**Per eseguire una query per la visualizzazione**
1. Apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel pannello di navigazione scegli **Logs** (Registri), quindi **Logs Insights**.
1. Conferma che la scheda **Logs Insights QL** sia selezionata.
1. Nell'elenco a discesa **Select log group(s)** (Seleziona uno o più gruppi di log), scegli uno o più gruppi di log su cui eseguire query.
Se si tratta di un account di monitoraggio in CloudWatch modalità osservabile su più account, è possibile selezionare gruppi di log negli account di origine e nell'account di monitoraggio. Una singola query può interrogare i log di diversi account contemporaneamente.
È possibile filtrare i gruppi di log in base al nome del gruppo di log, all'ID account o all'etichetta dell'account.
1. Nell'editor di query, eliminare i contenuti correnti, immettere la funzione seguente `stats` quanto segue e scegliere **Run query (Esegui query)**.
```
stats count(*) by bin(30s)
```
I risultati mostrano il numero di eventi di registro nel gruppo di log ricevuti da CloudWatch Logs per ogni periodo di 30 secondi.
1. Seleziona la scheda **Visualization (Visualizzazione)**.
I risultati sono mostrati come un grafico a linee. Per passare a un grafico a barre, grafico a torta o grafico ad area in pila, scegli la freccia accanto a **Line (Linea)** in alto a sinistra del grafico.
# Query di esempio
[Questa sezione contiene un elenco di comandi di query generali e utili che è possibile eseguire nella console. CloudWatch](https://console.aws.amazon.com/cloudwatch/) Per informazioni su come eseguire un comando di query, consulta [Tutorial: Esegui e modifica una query di esempio](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_RunSampleQuery.html) nella *Amazon CloudWatch Logs User Guide*.
Per ulteriori informazioni sulla sintassi delle query, consulta. [CloudWatch Sintassi delle interrogazioni in linguaggio Logs Insights](CWL_QuerySyntax.md)
**Topics**
+ [Query generali](#CWL_QuerySyntax-examples-general)
+ [Query per i registri di Lambda](#CWL_QuerySyntax-examples-Lambda)
+ [Query per i flussi di log Amazon VPC](#CWL_QuerySyntax-examples-VPC)
+ [Query per i registri di Route 53](#CWL_QuerySyntax-examples-Route53)
+ [Interrogazioni per i log CloudTrail](#CWL_QuerySyntax-examples-CloudTrail)
+ [Interrogazioni per Amazon API Gateway](#CWL_QuerySyntax-examples-APIGateway)
+ [Query per il gateway NAT](#CWL_QuerySyntax-examples-NATGateway)
+ [Query per i registri del server Apache](#CWL_QuerySyntax-examples-Apache)
+ [Interrogazioni per Amazon EventBridge](#CWL_QuerySyntax-examples-EventBridge)
+ [Esempi del comando parse](#CWL_QuerySyntax-examples-parse)
## Query generali
**Trova i 25 log eventi aggiunti più di recente.**
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
**Ottieni un elenco del numero di eccezioni all'ora.**
```
filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
```
**Ottieni un elenco di log eventi che non sono eccezioni.**
```
fields @message | filter @message not like /Exception/
```
**Ottieni il log eventi più recente per ogni valore univoco del campo `server`.**
```
fields @timestamp, server, severity, message
| sort @timestamp asc
| dedup server
```
**Ottieni il log eventi più recente per ogni valore univoco del campo `server` per ogni tipo di `severity`.**
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server, severity
```
## Query per i registri di Lambda
**Determina la quantità di memoria per la quale è stato effettuato un provisioning eccessivo.**
```
filter @type = "REPORT"
| stats max(@memorySize / 1000 / 1000) as provisonedMemoryMB,
min(@maxMemoryUsed / 1000 / 1000) as smallestMemoryRequestMB,
avg(@maxMemoryUsed / 1000 / 1000) as avgMemoryUsedMB,
max(@maxMemoryUsed / 1000 / 1000) as maxMemoryUsedMB,
provisonedMemoryMB - maxMemoryUsedMB as overProvisionedMB
```
**Crea un report sulla latenza.**
```
filter @type = "REPORT" |
stats avg(@duration), max(@duration), min(@duration) by bin(5m)
```
**Cerca le invocazioni lente delle funzioni ed elimina le richieste duplicate che possono derivare da nuovi tentativi o dal codice lato client. In questa query, `@duration` è espresso in millisecondi.**
```
fields @timestamp, @requestId, @message, @logStream
| filter @type = "REPORT" and @duration > 1000
| sort @timestamp desc
| dedup @requestId
| limit 20
```
## Query per i flussi di log Amazon VPC
**Trova i primi 15 trasferimenti di pacchetti tra gli host:**
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
**Trova i primi 15 trasferimenti di byte per gli host su una determinata sottorete.**
```
filter isIpv4InSubnet(srcAddr, "192.0.2.0/24")
| stats sum(bytes) as bytesTransferred by dstAddr
| sort bytesTransferred desc
| limit 15
```
**Trova gli indirizzi IP che utilizzano UDP come protocollo di trasferimento dei dati.**
```
filter protocol=17 | stats count(*) by srcAddr
```
**Trova gli indirizzi IP in cui i record di flusso sono stati ignorati durante la finestra di acquisizione.**
```
filter logStatus="SKIPDATA"
| stats count(*) by bin(1h) as t
| sort t
```
**Trova un singolo record per ogni connessione, per risolvere i problemi di connettività di rete.**
```
fields @timestamp, srcAddr, dstAddr, srcPort, dstPort, protocol, bytes
| filter logStream = 'vpc-flow-logs' and interfaceId = 'eni-0123456789abcdef0'
| sort @timestamp desc
| dedup srcAddr, dstAddr, srcPort, dstPort, protocol
| limit 20
```
## Query per i registri di Route 53
**Trova la distribuzione di record all'ora in base al tipo di query.**
```
stats count(*) by queryType, bin(1h)
```
**Trova i 10 resolver DNS con il più elevato numero di richieste.**
```
stats count(*) as numRequests by resolverIp
| sort numRequests desc
| limit 10
```
**Trova il numero di record in base a dominio e sottodominio in cui il server non è riuscito a completare la richiesta DNS.**
```
filter responseCode="SERVFAIL" | stats count(*) by queryName
```
## Interrogazioni per i log CloudTrail
**Trova il numero di voci di registro per ogni servizio, tipo di evento e AWS regione.**
```
stats count(*) by eventSource, eventName, awsRegion
```
**Trova gli host Amazon EC2 che sono stati avviati o interrotti in una determinata AWS regione.**
```
filter (eventName="StartInstances" or eventName="StopInstances") and awsRegion="us-east-2"
```
**Trova le AWS regioni, i nomi utente e ARNs gli utenti IAM appena creati.**
```
filter eventName="CreateUser"
| fields awsRegion, requestParameters.userName, responseElements.user.arn
```
**Trova il numero di record in cui si è verificata un'eccezione durante il richiamo dell'API `UpdateTrail`.**
```
filter eventName="UpdateTrail" and ispresent(errorCode)
| stats count(*) by errorCode, errorMessage
```
**Trova le voci di log in cui è stato utilizzato TLS 1.0 o 1.1**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by userIdentity.accountId, recipientAccountId, eventSource, eventName, awsRegion, tlsDetails.tlsVersion, tlsDetails.cipherSuite, userAgent
| sort eventSource, eventName, awsRegion, tlsDetails.tlsVersion
```
**Trova il numero di chiamate per servizio che ha utilizzato le versioni TLS 1.0 o 1.1**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by eventSource
| sort numOutdatedTlsCalls desc
```
## Interrogazioni per Amazon API Gateway
Trova gli ultimi 10 errori 4XX
```
fields @timestamp, status, ip, path, httpMethod
| filter status>=400 and status<=499
| sort @timestamp desc
| limit 10
```
Identifica le 10 Amazon API Gateway richieste che richiedono più tempo nel tuo gruppo di log di accesso Amazon API Gateway
```
fields @timestamp, status, ip, path, httpMethod, responseLatency
| sort responseLatency desc
| limit 10
```
Restituisci l'elenco dei percorsi API più comuni nel gruppo di log di accesso Amazon API Gateway
```
stats count(*) as requestCount by path
| sort requestCount desc
| limit 10
```
Crea un report sulla latenza di integrazione per il gruppo di log di accesso Amazon API Gateway
```
filter status=200
| stats avg(integrationLatency), max(integrationLatency),
min(integrationLatency) by bin(1m)
```
## Query per il gateway NAT
Se noti costi superiori al normale nella tua AWS fattura, puoi utilizzare CloudWatch Logs Insights per trovare i principali contributori. Per ulteriori informazioni sui seguenti comandi di query, vedi [Come posso trovare i principali contributori al traffico attraverso il gateway NAT nel mio VPC](https://aws.amazon.com/premiumsupport/knowledge-center/vpc-find-traffic-sources-nat-gateway/)? nella pagina di supporto AWS premium.
**Nota**
Nei seguenti comandi di query, sostituisci "x.x.x.x" con l'IP privato del gateway NAT e "y.y" con i primi due ottetti dell'intervallo CIDR VPC.
**Trova le istanze che inviano più traffico attraverso il gateway NAT.**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Determina il traffico da e verso le istanze nei gateway NAT.**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.') or (srcAddr like 'xxx.xx.xx.xx' and dstAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Determina le destinazioni Internet con cui le istanze del VPC comunicano più spesso per caricamenti e download.**
*****Per i caricamenti*****
```
filter (srcAddr like 'x.x.x.x' and dstAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
*****Per i download*****
```
filter (dstAddr like 'x.x.x.x' and srcAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
## Query per i registri del server Apache
È possibile utilizzare CloudWatch Logs Insights per interrogare i log del server Apache. Per ulteriori informazioni sulle seguenti domande, consulta [Semplificazione dei log del server Apache con CloudWatch Logs Insights](https://aws.amazon.com/blogs/mt/simplifying-apache-server-logs-with-amazon-cloudwatch-logs-insights/) nel blog Cloud Operations & Migrations. AWS
**Trova i campi più pertinenti in modo da poter rivedere i log di accesso e verificare la presenza di traffico nel percorso */admin* dell'applicazione.**
```
fields @timestamp, remoteIP, request, status, filename| sort @timestamp desc
| filter filename="/var/www/html/admin"
| limit 20
```
**Trova il numero di richieste GET univoche che hanno effettuato l'accesso alla pagina principale con il codice di stato "200" (operazione riuscita).**
```
fields @timestamp, remoteIP, method, status
| filter status="200" and referrer= http://34.250.27.141/ and method= "GET"
| stats count_distinct(remoteIP) as UniqueVisits
| limit 10
```
**Trova il numero di volte in cui il servizio Apache è stato riavviato.**
```
fields @timestamp, function, process, message
| filter message like "resuming normal operations"
| sort @timestamp desc
| limit 20
```
## Interrogazioni per Amazon EventBridge
Ottieni il numero di EventBridge eventi raggruppati per tipo di dettaglio dell'evento
```
fields @timestamp, @message
| stats count(*) as numberOfEvents by `detail-type`
| sort numberOfEvents desc
```
## Esempi del comando parse
**Utilizza un'espressione glob per estrarre i campi `@user`, `@method` e `@latency` dal campo di log `@message` e restituire la latenza media per ogni combinazione univoca di `@method` e `@user`.**
```
parse @message "user=*, method:*, latency := *" as @user,
@method, @latency | stats avg(@latency) by @method,
@user
```
**Utilizza un'espressione regolare per estrarre i campi temporanei `@user2`, `@method2` e `@latency2` dal campo di log `@message` e restituire la latenza media per ogni combinazione univoca di `@method2` e `@user2`.**
```
parse @message /user=(?.*?), method:(?.*?),
latency := (?.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Estrae i campi `loggingTime`, `loggingType` e `loggingMessage`, filtra per log eventi che contengono le stringhe `ERROR` o `INFO` e quindi mostra solo i campi `loggingMessage` e `loggingType` per gli eventi che contengono una stringa `ERROR`.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# Confronta (diff) con gli intervalli di tempo precedenti
Puoi utilizzare CloudWatch Logs Insights con Logs Insights QL per confrontare le modifiche degli eventi di registro nel tempo. È possibile confrontare gli eventi di registro acquisiti durante un intervallo di tempo recente con i registri del periodo immediatamente precedente. In alternativa, è possibile effettuare il confronto con periodi di tempo precedenti simili. Questo può aiutarti a scoprire se un errore nei registri è stato introdotto di recente o se si è già verificato e può aiutarti a individuare altre tendenze.
Le query di confronto restituiscono solo modelli nei risultati, non eventi di log non elaborati. I modelli restituiti ti aiuteranno a visualizzare rapidamente le tendenze e le modifiche negli eventi di registro nel tempo. Dopo aver eseguito una query di confronto e aver ottenuto i risultati del pattern, puoi visualizzare esempi di eventi di log non elaborati per i pattern che ti interessano. Per ulteriori informazioni sui modelli di log, consulta[Analisi del modello](CWL_AnalyzeLogData_Patterns.md).
Quando si esegue una query di confronto, la query viene analizzata in base a due diversi periodi di tempo: il periodo di interrogazione originale selezionato e il periodo di confronto. Il periodo di confronto ha sempre la stessa durata del periodo di interrogazione originale. Gli intervalli di tempo predefiniti per i confronti sono i seguenti.
+ **Periodo precedente**: viene confrontato con il periodo di tempo immediatamente precedente al periodo di tempo della query.
+ **Giorno precedente**: viene confrontato con il periodo di tempo del giorno precedente al periodo di tempo della query.
+ **Settimana precedente**: viene confrontato con il periodo di tempo della settimana precedente al periodo di tempo della query.
+ **Mese precedente**: viene confrontato con il periodo di tempo di un mese precedente al periodo di tempo della richiesta.
**Nota**
Le query che utilizzano i confronti comportano costi simili all'esecuzione di una singola query di CloudWatch Logs Insights nell'intervallo di tempo combinato. Per ulteriori informazioni, consulta [Prezzi di Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).
**Per eseguire una query di confronto**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione scegli **Logs**, quindi **Logs Insights**.
Nella casella di interrogazione viene visualizzata un'interrogazione predefinita.
1. Conferma che la scheda **Logs Insights QL** sia selezionata.
1. Mantieni la query predefinita o inserisci una query diversa.
1. Nel **menu a discesa Seleziona gruppi di log**, scegli uno o più gruppi di log da interrogare.
1. (Facoltativo) Utilizza il selettore temporale per selezionare un periodo di tempo per il quale desideri eseguire query. L'interrogazione predefinita riguarda l'ora precedente di dati di registro.
1. Nel selettore dell'intervallo di tempo, scegli **Confronta**. **Quindi scegli il periodo di tempo precedente con cui vuoi confrontare i log originali e scegli Applica.**
1. Scegli **Esegui query**.
Per fare in modo che la query recuperi i dati del periodo di confronto, il `diff` comando viene aggiunto alla query.
1. Scegli la scheda **Patterns** per vedere i risultati.
La tabella mostra le seguenti informazioni:
+ Ogni **pattern**, con parti variabili del pattern sostituite dal simbolo del token dinamico``. *string*È una descrizione del tipo di dati che il token rappresenta. *number*Mostra dove nel modello appare questo token, rispetto agli altri token dinamici. Per ulteriori informazioni, consulta [Analisi del modello](CWL_AnalyzeLogData_Patterns.md).
+ Il **conteggio degli eventi** è il numero di eventi di registro con quel pattern nel periodo di tempo originale, più attuale.
+ Il **conteggio degli eventi** di differenza è la differenza tra il numero di eventi di registro corrispondenti nel periodo di tempo corrente e il periodo di confronto. Un valore diverso positivo indica che vi sono più eventi di questo tipo nel periodo di tempo corrente.
+ **La descrizione della differenza** riassume brevemente la variazione di tale schema tra il periodo di tempo corrente e il periodo di confronto.
+ Il **tipo di severità** è la gravità probabile degli eventi di registro con questo schema, in base a parole trovate negli eventi del registro come`FATAL`, `ERROR` e. `WARN`
1. Per esaminare ulteriormente uno dei modelli nell'elenco, scegliete l'icona nella colonna **Ispeziona** per uno dei modelli.
Viene visualizzato il riquadro **Pattern Inspect** che mostra quanto segue:
+ Il **modello.** Seleziona un token all'interno del pattern per analizzare i valori di quel token.
+ Un istogramma che mostra il numero di occorrenze del pattern nell'intervallo di tempo richiesto. Questo può aiutarvi a identificare tendenze interessanti, ad esempio un aumento improvviso della ricorrenza di un pattern.
+ La scheda **Registra esempi** mostra alcuni degli eventi di registro che corrispondono al modello selezionato.
+ La scheda **Valori dei token** mostra i valori del token dinamico selezionato, se ne è stato selezionato uno.
**Nota**
Per ogni token vengono acquisiti un massimo di 10 valori di token. Il conteggio dei token potrebbe non essere preciso. CloudWatch Logs utilizza un contatore probabilistico per generare il conteggio dei token, non il valore assoluto.
+ La scheda **Schemi correlati** mostra altri motivi che si sono verificati frequentemente più o meno nello stesso periodo del modello che si sta esaminando. Ad esempio, se lo schema di un `ERROR` messaggio era in genere accompagnato da un altro evento di registro contrassegnato `INFO` con dettagli aggiuntivi, tale modello viene visualizzato qui.
# Visualizzazione dei dati di log nei grafici
È possibile utilizzare visualizzazioni come grafici a barre, grafici a linee e grafici ad area in pila per identificare in modo più efficiente i modelli nei dati di registro. CloudWatch Logs Insights genera visualizzazioni per le query che utilizzano la `stats` funzione e una o più funzioni di aggregazione. Per ulteriori informazioni, consulta [stats](CWL_QuerySyntax-Stats.md).