.*?)/ | 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).
# OpenSearch Piped Processing Language (PPL)
Questa sezione contiene un'introduzione di base all'interrogazione dei CloudWatch log utilizzando PPL. OpenSearch Con PPL, è possibile recuperare, interrogare e analizzare i dati utilizzando comandi concatenati, semplificando la comprensione e la composizione di interrogazioni complesse. La sua sintassi si basa sulle pipe Unix e consente il concatenamento di comandi per trasformare ed elaborare i dati. Con PPL, puoi filtrare e aggregare i dati e utilizzare un ricco set di funzioni matematiche, di stringhe, di data, condizionali e di altro tipo per l'analisi.
L'inclusione `SOURCE` in una query PPL è un modo utile per specificare i gruppi di log, gli indici di campo e le fonti di dati da includere in una query quando si utilizza l' AWS CLI API o per creare una query. Il `SOURCE` comando è supportato solo nell'API AWS CLI and, non nella console. CloudWatch Quando si utilizza la CloudWatch console per avviare una query, si utilizza l'interfaccia della console per specificare i gruppi di log e il nome e il tipo di origine dati.
`aws:fieldIndex`Da utilizzare per restituire solo dati indicizzati, forzando una query a scansionare solo i gruppi di log indicizzati su un campo specificato nella query. I gruppi di log pertinenti vengono selezionati automaticamente, in base ai campi specificati nel comando. `filterIndex` Ciò riduce il volume scansionato ignorando i gruppi di log che non contengono eventi di registro contenenti il campo specificato nella query e analizzando solo i gruppi di log che corrispondono al valore specificato nella query per questo indice di campo. `aws:fieldIndex`Utilizzatelo per specificare il nome del campo, insieme al nome e al valore del campo nel comando di origine, per interrogare solo i dati indicizzati contenenti il campo e il valore specificati. Per ulteriori informazioni, consulta [Crea indici di campo per migliorare le prestazioni delle query e ridurre il volume di scansione](CloudWatchLogs-Field-Indexing.md)
È possibile utilizzare OpenSearch PPL per le interrogazioni dei gruppi di log nella Standard Log Class.
**Nota**
Per informazioni su tutti i comandi di interrogazione OpenSearch PPL supportati nei CloudWatch registri e informazioni dettagliate sulla sintassi e le restrizioni, vedere [Comandi PPL supportati](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-ppl.html) nella Service Developer Guide. OpenSearch
[Per informazioni su altri linguaggi di interrogazione che è possibile utilizzare, vedere [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), Service SQL e OpenSearch [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html)](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_SQL.html)
| Comando o funzione | Query di esempio | Description |
| --- | --- | --- |
| campi | `fields field1, field2` | Visualizza un insieme di campi che necessitano di proiezione. |
| join | `LEFT JOIN left=l, right=r on l.id = r.id `join_right_lg` \| fields l.field_1, r.field_2` | Unisce due set di dati. |
| dove | `where field1="success" \| where field2 != "i-023fe0a90929d8822" \| fields field3, field4, field5,field6 \| head 1000` | Filtra i dati in base alle condizioni specificate. |
| AWS: FieldIndex | `source = [`aws:fieldIndex`="region", `region` = "us-west-2"] \| where status = 200 \| head 10` | Restituisce solo dati indicizzati, forzando una query a scansionare solo i gruppi di log indicizzati su un campo specificato nella query. |
| stats | `stats count(), count(field1), min(field1), max(field1), avg(field1) by field2 \| head 1000` | Esegue aggregazioni e calcoli |
| parse | `parse field1 ".*/(?[^/]+$)" \| where field2 = "requestId" \| fields field1, field2 \| head 1000` | Estrae un pattern di espressione regolare (regex) da una stringa e visualizza il pattern estratto. Il pattern estratto può essere ulteriormente utilizzato per creare nuovi campi o filtrare i dati. |
| sort | `stats count(), count(field1), min(field1) as field1Alias, max(`field1`), avg(`field1`) by field2 \| sort -field1Alias \| head 1000` | Ordina i risultati visualizzati in base al nome di un campo. Usa sort - FieldName per ordinare in ordine decrescente. |
| eval | `eval field2 = field1 * 2 \| fields field1, field2 \| head 20` | Modifica o elabora il valore di un campo e lo memorizza in un campo diverso. Ciò è utile per modificare matematicamente una colonna, applicare funzioni di stringa a una colonna o applicare funzioni di data a una colonna. |
| rinominare | `rename field2 as field1 \| fields field1;` | Rinomina uno o più campi nel risultato della ricerca. |
| head | `fields `@message` \| head 20` | Limita i risultati dell'interrogazione visualizzati alle prime N righe. |
| top | `top 2 field1 by field2` | Trova i valori più frequenti per un campo. |
| dedup | `dedup field1 \| fields field1, field2, field3` | Rimuove le voci duplicate in base ai campi specificati. |
| rari | `rare field1 by field2` | Trova i valori meno frequenti di tutti i campi nell'elenco dei campi. |
| subquery | `where field_1 IN [ search source= `subquery_lg` \| fields field_2 ] \| fields id, field_1 ` | Esegue interrogazioni complesse e annidate all'interno delle istruzioni PPL. |
| linea di tendenza | `trendline sma(2, field1) as field1Alias` | Calcola le medie mobili dei campi. |
| EventStats | `eventstats sum(field1) by field2` | Arricchisce i dati degli eventi con statistiche riassuntive calcolate. Analizza campi specifici all'interno degli eventi, calcola varie misure statistiche e quindi aggiunge questi risultati a ciascun evento originale come nuovi campi. |
| espansione | `eval tags_array_string = json_extract(`@message`, '$.tags')\| eval tags_array = json_array(json_extract(tags_string, '$[0]'), json_extract(tags_string, '$[1]'))\| expand tags_array as color_tags` | Suddivide un campo contenente più valori in righe separate, creando una nuova riga per ogni valore nel campo specificato. |
| riempi/null | `fields `@timestamp`, error_code, status_code \| fillnull using status_code = "UNKNOWN", error_code = "UNKNOWN"` | Riempie i campi nulli con il valore fornito. Può essere utilizzato in uno o più campi. |
| flatten | `eval metadata_struct = json_object('size', json_extract(metadata_string, '$.size'), 'color', json_extract(metadata_string, '$.color')) \| flatten metadata_struct as (meta_size, meta_color) ` | Appiattisce un campo. Il campo deve essere di questo tipo: `struct` o. `array>` |
| cidrmatch | `where cidrmatch(ip, '2003:db8::/32') \| fields ip ` | Verifica se l'indirizzo IP specificato rientra nell'intervallo CIDR specificato. |
| riepilogo del campo | `where field1 != 200 \| fieldsummary includefields= field1 nulls=true` | Calcola le statistiche di base per ogni campo (conteggio, conteggio distinto, min, max, avg, stddev e mean). |
| grok | `grok email '.+@%{HOSTNAME:host}' \| fields email, host` | Analizza un campo di testo con uno schema grok e aggiunge i risultati al risultato della ricerca. |
| Funzioni stringa | `eval field1Len = LENGTH(field1) \| fields field1Len` | Funzioni integrate in PPL che possono manipolare e trasformare stringhe e dati di testo all'interno di query PPL. Ad esempio, convertire maiuscole e minuscole, combinare stringhe, estrarre parti e pulire il testo. |
| Funzioni data-ora | `eval newDate = ADDDATE(DATE('2020-08-26'), 1) \| fields newDate ` | Funzioni integrate per la gestione e la trasformazione dei dati di data e ora nelle query PPL. Ad esempio, date\$1add, date\$1format, datediff, date-sub, timestampadd, timestampdiff, current\$1timezone, utc\$1timestamp e current\$1date. |
| Funzioni di condizione | `eval field2 = isnull(field1) \| fields field2, field1, field3` | Funzioni integrate che controllano le condizioni specifiche dei campi e valutano le espressioni in modo condizionale. Ad esempio, se field1 è nullo, restituisci field2. |
| Funzioni matematiche | `eval field2 = ACOS(field1) \| fields field1` | Funzioni integrate per eseguire calcoli e trasformazioni matematiche nelle interrogazioni PPL. Ad esempio, abs (valore assoluto), round (arrotonda i numeri), sqrt (radice quadrata), pow (calcolo della potenza) e ceil (arrotonda al numero intero più vicino). |
| CryptoGraphic funzioni | `eval crypto = MD5(field)\| head 1000` | Per calcolare l'hash di un determinato campo |
| Funzioni JSON | `eval valid_json = json('[1,2,3,{"f1":1,"f2":[5,6]},4]') \| fields valid_json` | Funzioni integrate per la gestione di JSON, tra cui array, estrazione e convalida. Ad esempio, json\$1object, json\$1array, to\$1json\$1string, json\$1array\$1length, json\$1extract, json\$1keys e json\$1valid. |
## Ambito della query
L'inclusione di SOURCE in una query è un modo utile per specificare i gruppi di log da includere in una query quando si utilizza l'API AWS CLI or per creare una query. Il comando SOURCE è supportato solo nell'API AWS CLI and, non nella CloudWatch console. Quando si utilizza la CloudWatch console per avviare una query, si utilizza l'interfaccia della console per specificare i gruppi di log e il nome e il tipo di origine dati.
Il comando source di PPL ora supporta diversi modi per specificarli:
1. Gruppo di log
1. Indici di campo - Nuovi
1. Fonte e tipo di dati: nuovo
### Gruppo di log
La selezione della fonte del gruppo di log può essere utilizzata quando i clienti sanno esattamente quali gruppi di log devono essere cercati
```
source = [lg:`/aws/lambda/my-function`] | where status = 200 | head 10
```
### Indici di campo
La selezione dell'origine basata sull'indice dei campi riduce la quantità di dati interrogati limitando i risultati ai soli dati indicizzati quando i filtri riguardano i campi che sono stati indicizzati. I gruppi di log pertinenti vengono selezionati automaticamente, in base ai campi specificati nel comando. `filterIndex` Per ulteriori informazioni sugli indici di campo e su come crearli, consulta [Creare indici di campo per migliorare le prestazioni delle query e ridurre](CloudWatchLogs-Field-Indexing.md) il volume di scansione.
`aws:fieldIndex`Da utilizzare per restituire solo dati indicizzati, forzando una query a scansionare solo i gruppi di log indicizzati su un campo specificato nella query. Per questi gruppi di log indicizzati in questo campo, ottimizza ulteriormente la query ignorando i gruppi di log che non contengono eventi di registro contenenti il campo specificato nella query per il campo indicizzato. Riduce ulteriormente il volume scansionato tentando di analizzare solo gli eventi di registro di questi gruppi di log che corrispondono al valore specificato nella query per questo indice di campo. Per ulteriori informazioni sugli indici di campo e su come crearli, consulta Creare indici di campo per migliorare le prestazioni delle query e ridurre il volume di scansione.
In PPL, `aws:fieldIndex` viene utilizzato per specificare quali coppie chiave-valore devono essere trattate come indici. La sintassi è la seguente
```
source = [`aws:fieldIndex`="region", `region` = "us-west-2"] | where status = 200 | head 10
```
dove:
1. ``aws:fieldIndex`="region"`identifica la regione come campo Index.
1. Nota: invece di = i clienti possono utilizzare IN per specificare più indici (esempio seguente)
1. ``region`="us-west-2"`identifica la condizione del filtro da applicare
1. Nota: invece di = i clienti possono utilizzare IN per specificare più valori (esempio seguente)
I clienti possono specificare più FieldIndex come segue
```
source = [`aws:fieldIndex` IN ("status", "region"), `status` = 200, `region` IN ("us-west-2", "us-east-1")] | head 10
```
### Fonte e tipo di dati
La selezione della fonte di dati e della fonte basata sul tipo può essere utilizzata quando i clienti sanno esattamente quali fonti di dati devono essere interrogate. Questa query viene eseguita su uno o più gruppi di log che contengono l'origine e il tipo di dati specificati.
```
source = [ds:`data_source.type`] | where status = 200 | head 10
```
#### PPL supportato per le interrogazioni sulle fonti di dati
Per supportare il caso d'uso per l'interrogazione di sorgenti di dati in PPL, è possibile utilizzare la clausola Dynamic Source Selector. Utilizzando questa sintassi, è possibile interrogare le fonti di dati specificandole nel comando di ricerca. È possibile specificare fino a 10 fonti di dati.
**Sintassi**
```
source=[ds:`DataSource1.Type1`, ds:`DataSource2.Type2`, ...ds:`DataSourcen.Typen`]
```
**Query di esempio**
```
search source=[ds:`DataSource1.Type1`, ds:`DataSource2.Type2`] | fields field1, field2
```
### Esempio per la combinazione
I clienti possono specificare tutti gli operatori di selezione della sorgente in qualsiasi ordine e i risultati sarebbero l'intersezione di tutte le condizioni applicate.
Ad esempio,/aws/lambda/my-function-1 potrebbe contenere più fonti e tipi di dati tra cui un'ampia varietà di indici. Quando viene eseguita la seguente query, i risultati restituiti avranno solo eventi di origine e tipo DataSource 1.Type1 e corrispondenti ai criteri di 'status' = 200.
```
search source=[
ds:`DataSource1.Type1`,
lg:`/aws/lambda/my-function-1`,
`aws:fieldIndex` IN ("status"), `status` = 200
]
```
## Restrizioni
Le seguenti restrizioni si applicano quando si utilizza OpenSearch PPL per eseguire query in Logs Insights. CloudWatch
+ Non è possibile utilizzare i comandi join o subquery con le query relative alle fonti di dati.
# OpenSearch Structured Query Language (SQL)
Questa sezione contiene un'introduzione di base all'interrogazione dei CloudWatch log utilizzando OpenSearch SQL. Fornisce un'opzione familiare se sei abituato a lavorare con database relazionali. OpenSearch SQL offre un sottoinsieme di funzionalità SQL, il che lo rende una buona scelta per eseguire query ad hoc e attività di analisi dei dati. Con OpenSearch SQL, è possibile utilizzare comandi come SELECT, FROM, WHERE, GROUP BY, HAVING e vari altri comandi e funzioni SQL. È possibile eseguire JOINs più gruppi di log, correlare i dati tra gruppi di log utilizzando sottoquery e utilizzare il ricco set di funzioni SQL JSON, matematiche, di stringa, condizionali e di altro tipo per eseguire analisi approfondite sui dati di log e di sicurezza.
Consente `filterIndex` di restituire solo dati indicizzati, forzando una query a scansionare solo i gruppi di log indicizzati in un campo specificato nella query. Riduci il volume scansionato ignorando i gruppi di log che non contengono eventi di registro contenenti il campo specificato nella query e analizzando solo i gruppi di log che corrispondono al valore specificato nella query per questo indice di campo. `filterIndex`Utilizzatelo per specificare il nome del campo, insieme al nome e al valore del campo, per interrogare solo i dati indicizzati contenenti il campo e il valore specificati.
È possibile utilizzare OpenSearch SQL per le interrogazioni dei gruppi di log nella classe di log standard. SQL supporta anche l'esecuzione di query utilizzando il nome dell'origine dati e il tipo di origine dati.
**Nota**
Nella tabella seguente sono elencati i comandi e le funzioni SQL supportati nei CloudWatch registri. Per informazioni su tutti i comandi OpenSearch SQL, inclusa la sintassi, vedere [Comandi SQL supportati](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-directquery-sql.html) nella OpenSearch Service Developer Guide.
Per informazioni sugli altri linguaggi di query che è possibile utilizzare, vedere [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [OpenSearch Service PPL](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_PPL.html) e. [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html)
## Comandi SQL supportati
**Nota**
Nella colonna della query di esempio, `` sostituiscila secondo necessità a seconda della fonte di dati su cui stai interrogando.
| Comando o funzione | Query di esempio | Description |
| --- | --- | --- |
| SELECT | `SELECT `@message`, Operation FROM `LogGroupA`` | Visualizza i valori proiettati. |
| FROM | `SELECT `@message`, Operation FROM `LogGroupA`` | Clausola incorporata che specifica le tabelle o le viste di origine da cui recuperare i dati, supportando vari tipi di join e sottoquery. |
| WHERE | `SELECT * FROM `LogGroupA` WHERE Operation = 'x'` | Filtra gli eventi di registro in base ai criteri di campo forniti. |
| FilterIndex | `SELECT * FROM `filterIndex('region' = 'us-east-1')` WHERE status = 200 LIMIT 10;` | Restituisce solo dati indicizzati, forzando una query a scansionare solo i gruppi di log indicizzati in un campo specificato nella query. |
| GROUP BY | `SELECT `@logStream`, COUNT(*) as log_count FROM `LogGroupA` GROUP BY `@logStream`` | I gruppi registrano gli eventi in base alla categoria e trovano la media in base alle statistiche. |
| HAVING | `SELECT `@logStream`, COUNT(*) as log_count FROM `LogGroupA` GROUP BY `@logStream` HAVING log_count > 100` | Filtra i risultati in base alle condizioni di raggruppamento. |
| ORDER BY | `SELECT * FROM `LogGroupA` ORDER BY `@timestamp` DESC` | Ordina i risultati in base ai campi della clausola ORDER BY. È possibile ordinare in ordine decrescente o crescente. |
| JOIN | `SELECT A.`@message`, B.`@timestamp`FROM `LogGroupA` as A INNER JOIN `LogGroupB` as B ON A.`requestId` = B.`requestId`` | Unisce i risultati di due tabelle in base a campi comuni. È necessario specificare Inner JOIN o Left Outer Join |
| LIMIT | `Select * from `LogGroupA` limit 10` | Limita i risultati della query visualizzati alle prime N righe. |
| Funzioni stringa | `SELECT upper(Operation) , lower(Operation), Operation FROM `LogGroupA`` | Funzioni integrate in SQL in grado di manipolare e trasformare stringhe e dati di testo all'interno di query SQL. Ad esempio, la conversione di maiuscole e minuscole, la combinazione di stringhe, l'estrazione di parti e la pulizia del testo. |
| Funzioni di data | `SELECT current_date() as today, date_add(current_date(), 30) as thirty_days_later, last_day(current_date()) as month_end FROM `LogGroupA`` | Funzioni integrate per la gestione e la trasformazione dei dati di data e ora nelle query SQL. Ad esempio, date\$1add, date\$1format, datediff e current\$1date. |
| Funzioni condizionali | `SELECT Operation, IF(Error > 0, 'High', 'Low') as error_category FROM `LogGroupA`;` | Funzioni integrate che eseguono azioni in base a condizioni specifiche o che valutano le espressioni in modo condizionale. Ad esempio, CASE e IF. |
| Funzioni di aggregazione | `SELECT AVG(bytes) as bytesWritten FROM `LogGroupA`` | Funzioni integrate che eseguono calcoli su più righe per produrre un unico valore riepilogato. Ad esempio, SUM, COUNT, AVG, MAX e MIN. |
| Funzioni JSON | `SELECT get_json_object(json_column, '$.name') as name FROM `LogGroupA`` | Funzioni integrate per l'analisi, l'estrazione, la modifica e l'interrogazione di dati in formato JSON all'interno delle query SQL (ad esempio, from\$1json, to\$1json, get\$1json\$1object, json\$1tuple) che consentono la manipolazione delle strutture JSON nei set di dati. |
| Funzioni di array | `SELECT scores, size(scores) as length, array_contains(scores, 90) as has_90 FROM `LogGroupA`;` | Funzioni integrate per lavorare con colonne di tipo array nelle query SQL, che consentono operazioni come l'accesso, la modifica e l'analisi dei dati dell'array (ad esempio, size, explode, array\$1contains). |
| Funzioni finestra | `SELECT field1, field2, RANK() OVER (ORDER BY field2 DESC) as field2Rank FROM `LogGroupA`;` | Funzioni integrate che eseguono calcoli su un insieme specifico di righe relative alla riga (finestra) corrente, abilitando operazioni come la classificazione, l'esecuzione dei totali e le medie mobili. Ad esempio, ROW\$1NUMBER, RANK, LAG e LEAD |
| Funzioni di conversione | `SELECT CAST('123' AS INT) as converted_number, CAST(123 AS STRING) as converted_string FROM `LogGroupA`` | Funzioni integrate per la conversione dei dati da un tipo all'altro all'interno delle query SQL, che consentono trasformazioni dei tipi di dati e conversioni di formato. Ad esempio, CAST, TO\$1DATE, TO\$1TIMESTAMP e BINARY. |
| Funzioni di predicato | `SELECT scores, size(scores) as length, array_contains(scores, 90) as has_90 FROM `LogGroupA`;` | Funzioni integrate che valutano le condizioni e restituiscono valori booleani (vero/falso) in base a criteri o modelli specifici. Ad esempio, IN, LIKE, BETWEEN, IS NULL ed EXISTS. |
| Seleziona più gruppi di log | `SELECT lg1.field1, lg1.field2 from `logGroups( logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` as lg1 where lg1.field3= "Success"` | Consente di specificare più gruppi di log in un'istruzione SELECT |
| Seleziona più fonti di dati | `SELECT ds1.field1, ds1.field2 from `dataSource(['DataSource1', 'DataSource2'])` as ds1 where ds1.field3= "Success"` | Consente di specificare più fonti di dati in un'istruzione SELECT |
## SQL supportato per le multi-log-group interrogazioni
Per supportare il caso d'uso per l'interrogazione di più gruppi di log in SQL, è possibile utilizzare il `logGroups` comando. Utilizzando questa sintassi, è possibile interrogare più gruppi di log specificandoli nel comando FROM.
Sintassi:
```
`logGroups(
logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn']
)
```
In questa sintassi, è possibile specificare fino a 50 gruppi di log nel parametro. `logGroupIdentifier` Per fare riferimento ai gruppi di log in un account di monitoraggio, usa ARNs al posto dei `LogGroup` nomi.
Query di esempio:
```
SELECT LG1.Column1, LG1.Column2 from `logGroups(
logGroupIdentifier: ['LogGroup1', 'LogGroup2']
)` as LG1 WHERE LG1.Column1 = 'ABC'
```
La seguente sintassi che coinvolge più gruppi di log dopo l'`FROM`istruzione NON è supportata durante l' CloudWatch interrogazione dei log.
```
SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn'
WHERE Column1 = 'ABC'
```
## SQL supportato per le interrogazioni sulle fonti di dati
Per supportare il caso d'uso per l'interrogazione di sorgenti di dati in SQL, è possibile utilizzare il comando DataSource. Utilizzando questa sintassi, è possibile interrogare le fonti di dati specificandole nel comando. `FROM` È possibile specificare fino a 10 fonti di dati.
**Sintassi**
```
`dataSource(
['DataSource1', 'DataSource2', ...'DataSourcen']
)`
```
**Query di esempio**
```
SELECT DS1.Column1, DS1.Column2 from `dataSource(
['DataSource1', 'DataSource2']
)` as DS1 WHERE DS1.Column1 = 'ABC'
```
## Ambito della query
Nell'API AWS CLI and, è possibile specificare i log da interrogare utilizzando il gruppo di log, l'origine e il tipo di dati e gli indici dei campi.
### Gruppo di log
La selezione della fonte del gruppo di log può essere utilizzata quando i clienti sanno esattamente quali gruppi di log devono essere cercati
```
SELECT * FROM `logGroups(logGroupIdentifier: ['/aws/lambda/my-function'])`;
```
### Fonte e tipo di dati
I clienti possono interrogare i propri registri utilizzando il nome e il tipo di origine dati.
La selezione delle fonti basata sull'origine dei dati e sul tipo può essere utilizzata quando i clienti sanno quali fonti di dati esatte devono essere interrogate. Questa query viene eseguita su uno o più gruppi di log che contengono l'origine e il tipo di dati specificati.
Per supportare il caso d'uso per l'interrogazione di sorgenti di dati in SQL, è possibile utilizzare il comando DataSource. Utilizzando questa sintassi, è possibile interrogare le fonti di dati specificandole nel comando FROM. È possibile specificare fino a 10 fonti di dati.
Sintassi:
```
`dataSource(
['DataSource1.Type1', 'DataSource2.Type2', ...'DataSourcen.Typen']
)`
```
Query di esempio:
```
SELECT DS1.Column1, DS1.Column2 from `dataSource(
['DataSource1.Type1', 'DataSource2.Type2']
)` as DS1 WHERE DS1.Column1 = 'ABC'
```
Per ulteriori informazioni sulle interrogazioni in base alle fonti di dati, vedere[Usa le sfaccettature per raggruppare ed esplorare i log](CloudWatchLogs-Facets.md).
### Esempio per la combinazione
I clienti possono specificare tutti gli operatori di selezione della fonte all'interno dei backtick in qualsiasi ordine e i risultati si baseranno sull'intersezione di tutte le condizioni applicate.
Ad esempio,/aws/lambda/my-function-1 potrebbe contenere più fonti e tipi di dati tra cui un'ampia varietà di indici. Quando viene eseguita la seguente query, i risultati restituiti avranno solo eventi di origine e tipo DataSource 1.Type1 e corrispondenti ai criteri di 'status' = 200.
```
SELECT * FROM `
logGroups(logGroupIdentifier: ['/aws/lambda/my-function'])
filterIndex('status' = 200)
dataSource(['DataSource1.Type1'])
`;
```
### Indici di campo
La selezione della fonte basata sull'indice di campo identifica automaticamente i gruppi di log pertinenti quando i filtri si rivolgono ai campi indicizzati, riducendo il volume di scansione e il tempo di esecuzione delle query.
`filterIndex`Da utilizzare per restituire solo dati indicizzati, forzando una query a scansionare solo i gruppi di log indicizzati su un campo specificato nella query. Per questi gruppi di log indicizzati in questo campo, ottimizza ulteriormente la query ignorando i gruppi di log che non contengono eventi di registro contenenti il campo specificato nella query per il campo indicizzato. Riduce ulteriormente il volume scansionato tentando di analizzare solo gli eventi di registro di questi gruppi di log che corrispondono al valore specificato nella query per questo indice di campo. Per ulteriori informazioni sugli indici di campo e su come crearli, consulta [Creare indici di campo per migliorare le prestazioni delle query e ridurre il volume](CloudWatchLogs-Field-Indexing.md) di scansione.
In SQL, filterIndex viene utilizzato per specificare quali coppie chiave-valore devono essere trattate come indici. La sintassi è la seguente
```
SELECT * FROM `filterIndex('region' = 'us-east-1')`;
```
dove:
1. filterIndex (...) specifica, tratta i valori chiave al loro interno come indici di campo. Ogni coppia chiave-valore è separata da una virgola (esempio seguente)
1. 'region' = 'us-east-1' specifica la condizione effettiva da applicare
1. Nota: invece di = i clienti possono utilizzare IN per specificare più valori (esempio seguente)
L'utilizzo di FilterIndex multiplo combinerebbe le condizioni utilizzando «AND». Nell'esempio, verrebbero interrogati i log che corrispondono a status=200 e region in us-east-1 o us-west-2.
```
SELECT * FROM `filterIndex('status' = 200, 'region' IN ['us-east-1', 'us-west-2'])`;
```
## Restrizioni
Le seguenti restrizioni si applicano quando si utilizza SQL per eseguire query in Logs Insights. OpenSearch CloudWatch
+ È possibile includere un solo JOIN in un'istruzione SELECT.
+ Non è possibile utilizzare JOIN o sottoquery con query sull'origine dati.
+ È supportato solo un livello di sottoquery annidate.
+ Le query di istruzioni multiple separate da punto e virgola (;) non sono supportate.
+ Le query contenenti nomi di campo identici ma che differiscono solo per maiuscole e minuscole (ad esempio field1 e) non sono supportate. FIELD1
Ad esempio, la seguente query non è supportata:
```
Select AWSAccountId, AwsAccountId from LogGroup
```
Tuttavia, la seguente query è supportata perché il nome del campo (`@logStream`) è identico in entrambi i gruppi di log:
```
Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id
```
+ Le funzioni e le espressioni devono operare sui nomi dei campi e far parte di un'istruzione SELECT con un gruppo di log specificato nella clausola FROM.
Ad esempio, questa query non è supportata:
```
SELECT cos(10) FROM LogGroup
```
Questa interrogazione è supportata:
```
SELECT cos(field1) FROM LogGroup
```
+ Quando usi i comandi SQL o PPL, racchiudi alcuni campi tra i backtick per interrogarli correttamente. I backtick sono necessari per i campi con caratteri speciali (non alfabetici e non numerici). Ad esempio, racchiude e inserisce i segni di spunta rovesciati`@message`. `Operation.Export` `Test::Field` Non è necessario racchiudere campi con nomi puramente alfabetici nei backtick.
Query di esempio con campi semplici:
```
SELECT SessionToken, Operation, StartTime FROM `LogGroup-A`
LIMIT 1000;
```
Query simile con backtick aggiunti:
```
SELECT `@SessionToken`, `@Operation`, `@StartTime` FROM `LogGroup-A` LIMIT 1000;
```
# Usa il linguaggio naturale per generare e aggiornare CloudWatch le query di Logs Insights
CloudWatch [Logs supporta una funzionalità di interrogazione in linguaggio naturale per aiutarti a generare e aggiornare le query per [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [OpenSearch Service PPL, Service SQL](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_PPL.html) e. OpenSearch [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html)](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_SQL.html)
Con questa funzionalità, puoi porre domande o descrivere i dati di CloudWatch Logs che stai cercando in un inglese semplice. La funzionalità del linguaggio naturale genera un'interrogazione in base a un prompt immesso e fornisce una line-by-line spiegazione del funzionamento della query. Puoi anche aggiornare la tua query per analizzare ulteriormente i dati.
A seconda dell'ambiente, è possibile inserire richieste come «Quali sono i primi 100 indirizzi IP di origine per byte trasferiti?» e «Trova le 10 richieste di funzioni Lambda più lente».
**Nota**
La funzionalità di interrogazione in linguaggio naturale è un servizio regionale. Per alcune Regioni, la funzionalità effettua chiamate tra Regioni verso le Regioni degli Stati Uniti d'America per elaborare i prompt di query. Per ulteriori informazioni, consulta [Amazon CloudWatch estende il supporto regionale per il riepilogo dei risultati delle query in linguaggio naturale e la generazione di query](https://aws.amazon.com/about-aws/whats-new/2025/08/amazon-cloudwatch-region-support-query-result-summarization-query-generation/).
**Per generare una query di CloudWatch Logs Insights con questa funzionalità, apri l'editor di query di CloudWatch Logs Insights, seleziona il gruppo di log su cui desideri interrogare e scegli Genera query.**
**Importante**
Per utilizzare la funzionalità di interrogazione in linguaggio naturale, devi aver effettuato l'accesso con le politiche [CloudWatchLogsFullAccess[CloudWatchLogsReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsReadOnlyAccess.html)](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsFullAccess.html), [AdministratorAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AdministratorAccess.html), o [ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html)IAM o disporre dell'`cloudwatch:GenerateQuery`autorizzazione.
## Query di esempio
Gli esempi in questa sezione descrivono come generare e aggiornare le query utilizzando la funzionalità di linguaggio naturale.
**Nota**
Per ulteriori informazioni sull'editor di query e sulla sintassi di CloudWatch Logs Insights, vedere Sintassi delle query di [CloudWatch Logs Insights.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html)
### Esempi: generare una query in linguaggio naturale
Per generare un'interrogazione utilizzando il linguaggio naturale, inserisci un prompt e scegli **Genera nuova query**. Questo esempio mostra le interrogazioni che eseguono una ricerca di base.
**Prompt**
Di seguito è riportato un esempio di prompt che indirizza la capacità di cercare le 10 chiamate di funzione Lambda più lente.
```
Find the 10 slowest requests
```
**Query**
Di seguito è riportata la query che utilizza il linguaggio di query CloudWatch Logs Insights generata dalla funzionalità del linguaggio naturale in base al prompt. Nota come il prompt appare in un commento prima della query. Dopo l'esecuzione della query, puoi leggere una spiegazione del funzionamento della query.
```
# Find the 10 slowest requests
fields @timestamp, @message, @duration
| sort @duration desc
| limit 10
# This query retrieves the timestamp, message and duration fields from the logs and sorts them in descending order by duration to find the 10 slowest requests.
```
**Nota**
Per disattivare la visualizzazione del prompt e la spiegazione del funzionamento della query, utilizza l'icona a forma di ingranaggio nell'editor.
**Prompt**
Per generare una query OpenSearch SQL, seleziona la scheda OpenSearch SQL, quindi apri la casella di richiesta del generatore di query per inserire il prompt del linguaggio naturale. Di seguito è riportato un esempio di prompt che utilizza la funzionalità del linguaggio naturale per generare una OpenSearch query SQL.
```
Give me the number of errors and exceptions per hour
```
**Query**
Di seguito è riportata la query SQL generata da quel prompt che è possibile utilizzare per trovare il numero di errori ed eccezioni aggregati all'ora:
```
SELECT DATE_FORMAT(`@timestamp`, 'yyyy-MM-dd HH') AS hour,
COUNT(*) AS error_count
FROM `/aws/lambda/CloudWatchOdysseyQueryGen`
WHERE `@message` LIKE '%error%'
OR `@message` LIKE '%exception%'
GROUP BY DATE_FORMAT(`@timestamp`, 'yyyy-MM-dd HH')
ORDER BY hour
```
**Prompt**
Per generare una query OpenSearch PPL, seleziona la scheda OpenSearch PPL, quindi apri la casella di richiesta del generatore di query per inserire il prompt del linguaggio naturale. Di seguito è riportato un esempio di prompt che utilizza la funzionalità del linguaggio naturale per generare una query PPL. OpenSearch
```
Give me all unique exception messages
```
**Query**
Di seguito è riportata la query PPL generata da quel prompt che è possibile utilizzare per trovare i messaggi di eccezione univoci nei registri:
```
dedup @message
| fields @message
```
### Esempio: aggiornamento di una query in linguaggio naturale
È possibile aggiornare una query modificando il prompt iniziale e scegliendo **Aggiorna query**.
**Richiesta aggiornata**
L'esempio seguente mostra una versione aggiornata del prompt precedente. Invece di un prompt che cerca le 10 chiamate di funzione Lambda più lente, questo prompt ora indirizza la capacità di cercare le 20 chiamate di funzione Lambda più lente e include un'altra colonna per eventi di registro aggiuntivi.
```
Show top 20 slowest requests instead and display requestId as a column
```
**Query aggiornata**
Di seguito è riportato un esempio di query aggiornata che utilizza il linguaggio di query Logs Insights. CloudWatch Nota come il prompt aggiornato appare in un commento prima della query aggiornata. Dopo l'esecuzione della query, puoi leggere una spiegazione di come la query originale è stata aggiornata.
```
# Show top 20 slowest requests instead and display requestId as a column
fields @timestamp, @message, @requestId, @duration
| sort @duration desc
| limit 20
# This query modifies the original query by replacing the @message field with the @requestId field and changing the limit from 10 to 20 to return the top 20 log events by duration instead of the top 10.
```
## Rifiuto esplicito all'utilizzo dei dati volto al miglioramento del servizio
I dati prompt in linguaggio naturale forniti per addestrare il modello di intelligenza artificiale e generare query pertinenti vengono utilizzati esclusivamente per fornire e gestire il servizio. Questi dati possono essere utilizzati per migliorare la qualità di CloudWatch Logs Insights. La tua fiducia, la tua privacy e la sicurezza dei tuoi contenuti sono le nostre maggiori priorità. Per ulteriori informazioni, consulta i [Termini del servizio AWS](https://aws.amazon.com/service-terms/) e la [Policy sull'IA responsabile di AWS](https://aws.amazon.com/machine-learning/responsible-ai/policy/).
Puoi scegliere di non utilizzare i tuoi contenuti per sviluppare o migliorare la qualità delle query in linguaggio naturale creando una policy di rifiuto dei servizi di intelligenza artificiale. Per disattivare la raccolta dei dati per tutte le funzionalità di CloudWatch Logs AI, inclusa la funzionalità di generazione di query, è necessario creare una politica di opt-out per Logs. CloudWatch Per ulteriori informazioni, consulta le [Policy di rifiuto dei servizi di IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) nella *Guida per l'utente di AWS Organizations *.
# Registri supportati e campi rilevati
CloudWatch Logs Insights supporta diversi tipi di log. Per ogni log inviato a un gruppo di log di classe Standard in Amazon CloudWatch Logs, CloudWatch Logs Insights genera automaticamente cinque campi di sistema:
+ `@message` contiene il log eventi non analizzato, non elaborato. Questo è l'equivalente del `message` campo in. [InputLogevent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html)
+ `@timestamp` contiene il timestamp dell'evento nel campo `timestamp` del log eventi. È l'equivalente del `timestamp` campo in [InputLogevent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html).
+ `@ingestionTime`contiene l'ora in cui CloudWatch Logs ha ricevuto l'evento di registro.
+ `@logStream` contiene il nome del flusso di log a cui il log eventi è stato aggiunto. I flussi di log raggruppano i registri in base allo stesso processo che li ha generati.
+ `@log` è un identificatore di gruppo di log sotto forma di `account-id:log-group-name`. Nelle query di più gruppi di log, può essere utile per identificare a quale gruppo di log appartiene un particolare evento.
+ `@entity`contiene JSON appiattito relativo alle entità per la funzionalità di telemetria relativa a [Explore](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ExploreRelated.html).
Ad esempio, questo JSON può rappresentare un'entità.
```
{
"Entity": {
"KeyAttributes": {
"Type": "Service",
"Name": "PetClinic"
},
"Attributes": {
"PlatformType": "AWS::EC2",
"EC2.InstanceId": "i-1234567890123"
}
}
}
```
Per questa entità, i campi di sistema estratti sarebbero i seguenti:
```
@entity.KeyAttributes.Type = Service
@entity.KeyAttributes.Name = PetClinic
@entity.Attributes.PlatformType = AWS::EC2
@entity.Attributes.EC2.InstanceId = i-1234567890123
```
**Nota**
L'individuazione dei campi è supportata 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).
CloudWatch Logs Insights inserisce il simbolo **@** all'inizio dei campi generati.
Per molti tipi di log, CloudWatch Logs rileva inoltre automaticamente i campi di log contenuti nei log. Questi campi di rilevamento automatici sono mostrati nella tabella seguente.
Per altri tipi di log con campi che CloudWatch Logs Insights non rileva automaticamente, puoi utilizzare il `parse` comando per estrarre e creare campi estratti da utilizzare in quella query. Per ulteriori informazioni, consulta [CloudWatch Sintassi delle interrogazioni in linguaggio Logs Insights](CWL_QuerySyntax.md).
Se il nome di un campo di registro rilevato inizia con il `@` carattere, CloudWatch Logs Insights lo visualizza con un altro `@` aggiunto all'inizio. Ad esempio, se un nome di un campo di log è `@example.com`, questo nome di campo viene visualizzato come `@@example.com`.
**Nota**
Ad eccezione di`@message`, o `@timestamp``@log`, è possibile creare indici di campo per i campi scoperti. Per ulteriori informazioni sugli indici di campo, vedere. [Crea indici di campo per migliorare le prestazioni delle query e ridurre il volume di scansione](CloudWatchLogs-Field-Indexing.md)
| Tipo di log | Campi di log rilevati |
| --- | --- |
| Log di flusso Amazon VPC | `@timestamp`, `@logStream`, `@message`, `accountId`, `endTime`, `interfaceId`, `logStatus`, `startTime`, `version`, `action`, `bytes`, `dstAddr`, `dstPort`, `packets`, `protocol`, `srcAddr`, `srcPort` |
| Log di Route 53 | `@timestamp`, `@logStream`, `@message`, `edgeLocation`, `ednsClientSubnet`, `hostZoneId`, `protocol`, `queryName`, `queryTimestamp`, `queryType`, `resolverIp`, `responseCode`, `version` |
| Log di Lambda | `@timestamp`, `@logStream`, `@message`, `@requestId`, `@duration, ``@billedDuration`, `@type`, `@maxMemoryUsed`, `@memorySize` Se una riga di log Lambda contiene un ID di traccia X-Ray, include anche i seguenti campi: `@xrayTraceId` e `@xraySegmentId`. CloudWatch Logs Insights rileva automaticamente i campi di registro nei log Lambda, ma solo per il primo frammento JSON incorporato in ogni evento di registro. Se un log eventi Lambda contiene più frammenti JSON, puoi analizzare ed estrarre i campi dei log utilizzando il comando `parse`. Per ulteriori informazioni, consulta [Campi nei registri JSON](#CWL_AnalyzeLogData-discoverable-JSON-logs). |
| CloudTrail registri Log in formato JSON | Per ulteriori informazioni, consulta [Campi nei registri JSON](#CWL_AnalyzeLogData-discoverable-JSON-logs). |
| Altri tipi di log | `@timestamp`, `@ingestionTime`, `@logStream`, `@message`, `@log`. |
## Campi nei registri JSON
Con CloudWatch Logs Insights, si utilizza la notazione a punti per rappresentare i campi JSON. Questa sezione contiene un esempio di evento e di frammento di codice JSON che mostra come accedere ai campi JSON utilizzando la notazione con il punto.
**Esempio: evento JSON**
```
{
"eventVersion": "1.0",
"userIdentity": {
"type": "IAMUser",
"principalId": "EX_PRINCIPAL_ID",
"arn": "arn: aws: iam: : 123456789012: user/Alice",
"accessKeyId": "EXAMPLE_KEY_ID",
"accountId": "123456789012",
"userName": "Alice"
},
"eventTime": "2014-03-06T21: 22: 54Z",
"eventSource": "ec2.amazonaws.com",
"eventName": "StartInstances",
"awsRegion": "us-east-2",
"sourceIPAddress": "192.0.2.255",
"userAgent": "ec2-api-tools1.6.12.2",
"requestParameters": {
"instancesSet": {
"items": [
{
"instanceId": "i-abcde123"
}
]
}
},
"responseElements": {
"instancesSet": {
"items": [
{
"instanceId": "i-abcde123",
"currentState": {
"code": 0,
"name": "pending"
},
"previousState": {
"code": 80,
"name": "stopped"
}
}
]
}
}
}
```
L'evento JSON di esempio contiene un oggetto denominato `userIdentity`. `userIdentity` contiene un campo denominato `type`. Per rappresentare il valore di `type` usando la notazione con il punto, utilizza `userIdentity.type`.
L'evento JSON di esempio contiene matrici che si livellano in elenchi di nomi e valori di campi annidati. Per rappresentare il valore di `instanceId` per il primo elemento di `requestParameters.instancesSet`, utilizza `requestParameters.instancesSet.items.0.instanceId`. Il numero `0` posizionato prima del campo `instanceID` si riferisce alla posizione dei valori per il campo `items`. L'esempio seguente contiene un frammento di codice che mostra come è possibile accedere ai campi JSON annidati in un log eventi JSON.
**Esempio: query**
```
fields @timestamp, @message
| filter requestParameters.instancesSet.items.0.instanceId="i-abcde123"
| sort @timestamp desc
```
Il frammento di codice mostra una query che utilizza la notazione con il punto con il comando `filter` per accedere al valore del campo JSON annidato `instanceId`. La query filtra i messaggi in cui il valore di `instanceId` è uguale a `"i-abcde123"` e restituisce tutti i log eventi che contengono il valore specificato.
**Nota**
CloudWatch Logs Insights può estrarre un massimo di 200 campi di eventi di registro da un registro JSON. Per i campi aggiuntivi che non vengono estratti, è possibile utilizzare il comando `parse` per estrarre questi campi dal log eventi non analizzato e non elaborato nel campo del messaggio. Per ulteriori informazioni sul `parse` comando, consulta la [sintassi delle query](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html) nella Amazon CloudWatch User Guide.
# Crea indici di campo per migliorare le prestazioni delle query e ridurre il volume di scansione
È possibile creare *indici di campo* dei campi negli eventi di registro per ricerche efficienti basate sull'uguaglianza. Quando poi si utilizza un indice di campo in una query di CloudWatch Logs Insights, la query tenta di ignorare l'elaborazione degli eventi di registro che notoriamente non includono il campo indicizzato. Ciò riduce il volume di scansione delle query che utilizzano gli indici di campo, rendendo possibile la restituzione dei risultati più rapidamente. Questo può aiutarti a cercare rapidamente petabyte di log totali in migliaia di gruppi di log e ad affinare più rapidamente i log pertinenti. I campi validi da indicizzare sono i campi per i quali spesso è necessario eseguire delle query. I campi con un'elevata cardinalità di valori sono anche ottimi candidati per gli indici di campo, perché una query che utilizza questi indici di campo verrà completata più rapidamente perché limita gli eventi di registro che vengono abbinati al valore di destinazione.
Ad esempio, supponiamo di aver creato un indice di campo per. `requestId` Quindi, qualsiasi query di CloudWatch Logs Insights su quel gruppo di log che includa `requestId = value` o `requestId IN [value, value, ...]` tenterà di elaborare solo gli eventi di registro che sono noti per contenere quel campo indicizzato e il valore interrogato e per i quali CloudWatch Logs ha rilevato un valore per quel campo in passato.
Puoi anche sfruttare gli indici dei campi per creare query efficienti su un numero maggiore di gruppi di log. Quando si utilizza il `filterIndex` comando nella query anziché il `filter` comando, la query verrà eseguita su gruppi di log selezionati sugli eventi di registro con indici di campo. Queste query possono scansionare fino a 10.000 gruppi di log, scelti specificando fino a cinque prefissi dei nomi dei gruppi di log. Se si tratta di un account di monitoraggio in modalità osservabile CloudWatch tra più account, è possibile scegliere tutti gli account di origine o specificare singoli account di origine per selezionare i «gruppi di log».
I campi indicizzati fanno distinzione tra maiuscole e minuscole. Ad esempio, un indice di campo non `RequestId` corrisponderà a un evento di registro contenente. `requestId`
Gli indici dei campi sono supportati solo per i formati di log strutturati di JSON e i log di servizio.
CloudWatch Logs fornisce indici di campo predefiniti per tutti i gruppi di log nella classe di log Standard. Gli indici di campo predefiniti sono automaticamente disponibili per i seguenti campi:
+ `@logStream`
+ `@aws.region`
+ `@aws.account`
+ `@source.log`
+ `@data_source_name`
+ `@data_source_type`
+ `@data_format`
+ `traceId`
+ `severityText`
+ `attributes.session.id`
CloudWatch Logs fornisce indici di campo predefiniti anche per determinate combinazioni di nomi e tipi di origini dati. Gli indici di campo predefiniti sono automaticamente disponibili per le seguenti combinazioni di nomi e tipi di origini dati:
| Nome e tipo di origine dati | Indici di campo predefiniti |
| --- | --- |
| `amazon_vpc.flow` | `action` `logStatus` `region` `flowDirection` `type` |
| `amazon_route53.resolver_query` | `query_type` `transport` `rcode` |
| `aws_waf.access` | `action` `httpRequest.country` |
| `aws_cloudtrail.data` ` aws_cloudtrail.management` | `eventSource` `eventName` `awsRegion` `userAgent` `errorCode` `eventType` `managementEvent` `readOnly` `eventCategory` `requestId` |
Gli indici di campo predefiniti si aggiungono a tutti gli indici di campo personalizzati definiti all'interno della politica. [Gli indici di campo predefiniti non vengono conteggiati ai fini della quota dell'indice di campo.](CloudWatchLogs-Field-Indexing-Syntax.md)
CloudWatch Registra gli indici solo gli eventi di registro acquisiti dopo la creazione di una politica di indicizzazione. Non indicizza gli eventi di registro acquisiti prima della creazione della policy. Dopo aver creato un indice di campo, ogni evento di registro corrispondente rimane indicizzato per 30 giorni dal momento di inserimento dell'evento di registro.
**Nota**
Se si crea una politica di indicizzazione dei campi in un account di monitoraggio, tale politica non viene utilizzata per i gruppi di log negli account di origine collegati. Una politica di indicizzazione dei campi si applica solo all'account in cui è stata creata.
Gli altri argomenti di questa sezione spiegano come creare indici di campo. Per informazioni sul riferimento agli indici di campo nelle query, consulta e. [FilterIndex](CWL_QuerySyntax-FilterIndex.md) [filter](CWL_QuerySyntax-Filter.md)
**Topics**
+ [Sintassi e quote degli indici di campo](CloudWatchLogs-Field-Indexing-Syntax.md)
+ [Crea una politica di indicizzazione dei campi a livello di account](CloudWatchLogs-Field-Indexing-CreateAccountLevel.md)
+ [Crea una politica di indicizzazione dei campi a livello di gruppo di log](CloudWatchLogs-Field-Indexing-CreateLogGroupLevel.md)
+ [Registra le opzioni di selezione dei gruppi durante la creazione di un'interrogazione](Field-Indexing-Selection.md)
+ [Effetti dell'eliminazione di una politica di indicizzazione dei campi](CloudWatchLogs-Field-Indexing-Deletion.md)
# Sintassi e quote degli indici di campo
*Gli indici di campo vengono creati creando criteri per gli indici di campo.* È possibile creare politiche di indicizzazione a livello di account che si applicano all'intero account e anche creare politiche che si applicano a un solo gruppo di log. Per quanto riguarda le politiche di indicizzazione a livello di account, puoi averne una che si applichi a tutti i gruppi di log dell'account. È inoltre possibile creare politiche di indicizzazione a livello di account che si applicano a un sottoinsieme di gruppi di log dell'account, selezionati in base ai prefissi dei nomi dei rispettivi gruppi di log. Se hai più politiche a livello di account nello stesso account, i prefissi dei nomi dei gruppi di log per queste politiche non possono sovrapporsi. Allo stesso modo, puoi creare politiche di indicizzazione a livello di account che si applicano a una combinazione specifica di nome e tipo di origine dati. È possibile creare una sola politica dell'account per combinazione di nome e tipo di origine dati.
Le politiche dell'indice dei campi a livello di gruppo di log hanno la precedenza sulle politiche dell'indice dei campi a livello di account: si applicano all'intero gruppo di log (ad esempio, le politiche a livello di account senza criteri di selezione o con criteri di selezione basati sul prefisso del nome del gruppo di log). Le politiche a livello di account che corrispondono a livello di evento di registro (ad esempio, per una determinata combinazione di nome e tipo di origine dati) verranno applicate in aggiunta alle politiche che corrispondono al gruppo di log nel suo insieme. Se si creano criteri di indicizzazione a livello di gruppo di log, tale gruppo di log non utilizza politiche a livello di account che corrispondono a livello di gruppo di log.
Le corrispondenze degli eventi di registro con i nomi degli indici dei campi fanno distinzione tra maiuscole e minuscole. Ad esempio, un indice di campo di non `RequestId` corrisponderà a un evento di registro contenente. `requestId`
È possibile avere fino a 40 criteri di indicizzazione a livello di account, di questi criteri 20 possono utilizzare criteri di selezione del prefisso del nome del gruppo di log e 20 possono utilizzare criteri di selezione basati sull'origine dei dati. Se hai più politiche di indicizzazione a livello di account filtrate in base ai prefissi dei nomi dei gruppi di log, nessuna di esse può utilizzare prefissi di nomi di gruppi di log uguali o sovrapposti. Ad esempio, se hai una politica filtrata in base ai gruppi di log che iniziano con`my-log`, non puoi avere un'altra politica di indice dei campi filtrata su o. `my-logpprod` `my-logging` Analogamente, se hai più policy di indicizzazione a livello di account filtrate in base a combinazioni di nomi e tipi di origini dati, non esistono due di esse che possano utilizzare lo stesso nome e tipo di origine dati. Ad esempio, se hai una politica filtrata in base al nome dell'origine dati `amazon_vpc` e al tipo di origine dati, non `flow` puoi creare un'altra politica con questa combinazione.
Se si dispone di una politica di indicizzazione a livello di account che non ha prefissi di nome e si applica a tutti i gruppi di log, non è possibile creare altre politiche di indicizzazione a livello di account con filtri per i prefissi dei nomi dei gruppi di log; è possibile creare politiche di indice a livello di account che utilizzano filtri per il nome e il tipo di origine dati.
Ogni politica di indicizzazione prevede le seguenti quote e restrizioni:
+ Nella policy possono essere inclusi fino a 20 campi.
+ Ogni nome di campo può includere fino a 100 caratteri.
+ Per creare un indice di un campo personalizzato nei gruppi di log che inizi con`@`, devi specificare il campo con un extra `@` all'inizio del nome del campo. Ad esempio, se gli eventi del registro includono un campo denominato`@userId`, è necessario specificare `@@userId` di creare un indice per questo campo.
Per le politiche di indicizzazione a livello di account con criteri di selezione basati sul nome dell'origine dati e sul tipo, si applica un'ulteriore restrizione: tutti i campi devono essere tipi di dati primitivi, le primitive annidate sono supportate solo per le strutture.
**Campi generati e campi riservati**
CloudWatch Logs Insights genera automaticamente campi di sistema in ogni evento di registro. Questi campi generati hanno il prefisso `@` Per ulteriori informazioni sui campi generati, vedere. [Registri supportati e campi rilevati](CWL_AnalyzeLogData-discoverable-fields.md)
Di questi campi generati, i seguenti sono supportati per l'uso come indici di campo:
+ `@logStream`
+ `@ingestionTime`
+ `@requestId`
+ `@type`
+ `@initDuration`
+ `@duration`
+ `@billedDuration`
+ `@memorySize`
+ `@maxMemoryUsed`
+ `@xrayTraceId`
+ `@xraySegmentId`
Per indicizzare questi campi generati, non è necessario aggiungerne un altro `@` quando li si specifica, come è necessario fare per i campi personalizzati che iniziano con. `@` Ad esempio, per creare un indice di campo per`@logStream`, è sufficiente specificare `@logStream` come indice di campo.
CloudWatch Logs fornisce indici di campo predefiniti per tutti i gruppi di log nella classe di log Standard. Gli indici di campo predefiniti sono automaticamente disponibili per i seguenti campi:
+ `@logStream`
+ `@aws.region`
+ `@aws.account`
+ `@source.log`
+ `@data_source_name`
+ `@data_source_type`
+ `@data_format`
+ `traceId`
+ `severityText`
+ `attributes.session.id`
CloudWatch Logs fornisce indici di campo predefiniti anche per determinate combinazioni di nomi e tipi di origini dati. Gli indici di campo predefiniti sono automaticamente disponibili per le seguenti combinazioni di nomi e tipi di origini dati:
| Nome e tipo di origine dati | Indici di campo predefiniti |
| --- | --- |
| `amazon_vpc.flow` | `action` `logStatus` `region` `flowDirection` `type` |
| `amazon_route53.resolver_query` | `query_type` `transport` `rcode` |
| `aws_waf.access` | `action` `httpRequest.country` |
| `aws_cloudtrail.data` ` aws_cloudtrail.management` | `eventSource` `eventName` `awsRegion` `userAgent` `errorCode` `eventType` `managementEvent` `readOnly` `eventCategory` `requestId` |
Gli indici di campo predefiniti si aggiungono a tutti gli indici di campo personalizzati definiti all'interno della politica. [Gli indici di campo predefiniti non vengono conteggiati ai fini della quota dell'indice di campo.](#CloudWatchLogs-Field-Indexing-Syntax)
**Campi secondari e campi array nei log JSON**
È possibile indicizzare i campi che sono campi secondari o campi array annidati nei log JSON.
Ad esempio, puoi creare un indice del campo `accessKeyId` figlio all'interno del `userIdentity` campo all'interno di questo registro:
```
{
"eventVersion": "1.0",
"userIdentity": {
"type": "IAMUser",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn: aws: iam: : 123456789012: user/Alice",
"accessKeyId": "11112222",
"accountId": "123456789012",
"userName": "Alice"
},
"eventTime": "2014-03-06T21: 22: 54Z",
"eventSource": "ec2.amazonaws.com",
"eventName": "StartInstances",
"awsRegion": "us-east-2",
"sourceIPAddress": "192.0.2.255",
"userAgent": "ec2-api-tools1.6.12.2",
"requestParameters": {
"instancesSet": {
"items": [{
"instanceId": "i-abcde123",
"currentState": {
"code": 0,
"name": "pending"
},
"previousState": {
"code": 80,
"name": "stopped"
}
}]
}
}
}
```
Per creare questo campo, vi fate riferimento utilizzando la notazione a punti (`userIdentity.accessKeyId`) sia durante la creazione dell'indice del campo che quando lo specificate in una query. L'interrogazione potrebbe avere il seguente aspetto:
```
fields @timestamp, @message
| filterIndex userIdentity.accessKeyId = "11112222"
```
Nell'evento di esempio precedente, il `instanceId` campo si trova in una matrice all'interno di `requestParameters.instancesSet.items` Per rappresentare questo campo sia durante la creazione dell'indice del campo che durante `requestParameters.instancesSet.items.0.instanceId` l'interrogazione, fate riferimento ad esso poiché 0 si riferisce alla posizione di quel campo nell'array.
Quindi una query per questo campo potrebbe essere la seguente:
```
fields @timestamp, @message
| filterIndex requestParameters.instancesSet.items.0.instanceId="i-abcde123"
```
# Crea una politica di indicizzazione dei campi a livello di account
Utilizza i passaggi descritti in questa sezione per creare una politica di indice dei campi che si applichi a tutti i gruppi di log dell'account o a più gruppi di log i cui nomi di gruppi di log iniziano con la stessa stringa.
**Per creare una politica di indicizzazione dei campi a livello di account**
1. Apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel riquadro di navigazione a sinistra, scegli **Impostazioni**, quindi scegli la scheda **Registri.**
1. Nella sezione **Politiche relative all'indice a livello di account**, scegli **Gestisci**.
1. Scegli **Crea politica sull'indice**.
1. Per **Nome della politica**, inserisci un nome per la nuova politica.
1. Per **Seleziona l'ambito della politica**, esegui una delle seguenti operazioni:
+ Scegliete **Tutti i gruppi di log standard** per applicare la politica di indicizzazione a tutti i gruppi di log di Standard Class presenti nell'account.
+ Scegli **Registra i gruppi per corrispondenza del prefisso** per applicare la politica a un sottoinsieme di gruppi di log i cui nomi iniziano con la stessa stringa. Quindi, inserisci il prefisso per questi gruppi di log in **Inserisci un nome** di prefisso.
Dopo aver inserito il prefisso, puoi scegliere **Anteprima dei gruppi di log corrispondenti al prefisso per confermare che il prefisso corrisponde ai gruppi** di log che ti aspettavi.
Scegli **Registra dati per origine dati per** applicare la politica a una combinazione specifica di nome e tipo di origine dati. Puoi quindi selezionare l'**origine dei dati** e il **tipo di dati** dal menu a discesa.
Dopo aver selezionato il nome e il tipo di origine dati, puoi selezionare **Ottieni campi** per compilare la sezione **Configura gli indici e i facet dei campi con informazioni pertinenti come i campi disponibili, i gruppi di log inclusi e gli indici di campo** predefiniti e personalizzati.
1. Per la **configurazione personalizzata dei campi indice**, scegli **Aggiungi percorso campo per inserire il primo campo** da indicizzare.
Quindi inserisci la stringa da utilizzare come valore del nome del campo o seleziona un campo dal menu a discesa. Deve corrispondere esattamente al maiuscolo/minuscolo visualizzato nel registro degli eventi. Ad esempio, se gli eventi di registro includono`requestId`, devi inserirli `requestId` qui. `RequestId``requestID`, e non `request Id` corrisponderebbe.
Se si desidera indicizzare un campo di registro personalizzato che inizia con il `@` carattere, è necessario includere un `@` carattere aggiuntivo quando si immette la stringa dell'indice. Ad esempio, se disponi di un campo di registro personalizzato`@emailname`, **inseriscilo `@@emailname` nella casella Aggiungi percorso del campo**.
Puoi anche creare indici per i `@logStream` campi `@ingestionTime` e generati automaticamente da CloudWatch Logs. In tal caso, non è necessario aggiungerne altri `@` quando li si specifica.
1. (Facoltativo) Oltre a specificare il percorso del campo, puoi selezionare **Imposta come sfaccettatura per creare il campo come sfaccettatura**.
1. Ripeti il passaggio precedente per aggiungere fino a 20 indici di campo.
1. Al termine, scegliere **Create (Crea)**.
# Crea una politica di indicizzazione dei campi a livello di gruppo di log
Utilizza i passaggi descritti in questa sezione per creare una politica di indice dei campi che si applichi a un singolo gruppo di log.
**Per creare una politica di indicizzazione dei campi a livello di gruppo di log**
1. Apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel pannello di navigazione a sinistra, scegli **Logs (Log)**, **Log groups (Gruppi di log)**.
1. Scegli il nome del gruppo di log.
1. Scegli la scheda **Indici di campo.**
1. Scegli **Gestisci gli indici dei campi per questo gruppo di log**
1. Per **Gestisci gli indici dei campi a livello di gruppo di log**, scegli **Aggiungi percorso di campo** per inserire il primo campo da indicizzare.
Quindi inserisci la stringa da utilizzare come valore del nome del campo. Deve corrispondere esattamente al maiuscolo/minuscolo visualizzato nel registro degli eventi. Ad esempio, se gli eventi di registro includono`requestId`, devi inserirli `requestId` qui. `RequestId``requestID`, e non `request Id` corrisponderebbe.
Se si desidera indicizzare un campo di registro personalizzato che inizia con il `@` carattere, è necessario includere un `@` carattere aggiuntivo quando si immette la stringa dell'indice. Ad esempio, se disponi di un campo di registro personalizzato`@emailname`, **inseriscilo `@@emailname` nella casella Aggiungi percorso del campo**.
Puoi anche creare indici per i `@logStream` campi `@ingestionTime` e generati automaticamente da CloudWatch Logs. In tal caso, non è necessario aggiungerne altri `@` quando li si specifica.
1. (Facoltativo) Oltre a specificare il percorso del campo, puoi selezionare **Imposta come sfaccettatura per creare il campo come sfaccettatura**.
1. Ripeti il passaggio precedente per aggiungere fino a 20 indici di campo.
1. Al termine, scegliere **Save** (Salva).
# Registra le opzioni di selezione dei gruppi durante la creazione di un'interrogazione
Questa sezione spiega i vari modi in cui è possibile selezionare i gruppi di log da includere in una query.
**Per selezionare i gruppi di log per un'interrogazione nella console**
1. Aprire 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**.
1. Seleziona la lingua di interrogazione che desideri utilizzare per questa interrogazione. **Puoi scegliere tra: **Logs Insights QL, **OpenSearchPPL** o OpenSearch SQL**.**
1. Esistono tre modi per selezionare i gruppi di log per la query:
+ Utilizzate la casella **Nome del gruppo di log**. Questo è il metodo di selezione predefinito. Con questo metodo è possibile inserire fino a 50 nomi di gruppi di log. Se si tratta di un account di monitoraggio in CloudWatch modalità 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.
+ Utilizza la sezione **Criteri del gruppo di log**. In questa sezione, è possibile scegliere i gruppi di log in base al prefisso dei nomi dei gruppi di log. È possibile includere fino a cinque prefissi in una query. Verranno selezionati i gruppi di log che hanno questi prefissi nei nomi. In alternativa, l'opzione **Tutti i gruppi di log** seleziona tutti i gruppi di log dall'account.
+ Se si tratta di un account di monitoraggio in modalità CloudWatch osservabile su più account, puoi selezionare **Tutti gli account** nel menu a discesa degli account per selezionare i gruppi di log tra tutti gli account collegati. In alternativa, puoi selezionare singolarmente quali account includere in questa query.
Se le tue scelte corrispondono a più di 10.000 gruppi di log, visualizzerai un errore che ti chiederà di restringere la selezione.
1. **La classe di log predefinita per una query è Standard.** È possibile utilizzare la **classe Log** per modificarla in **Accesso infrequente**.
**Usando la AWS CLI**
Per effettuare questo tipo di selezione quando si avvia una query dalla riga di comando, è possibile utilizzare il `source` comando contenuto nella query. Per maggiori informazioni ed esempi, consulta [SOURCE](CWL_QuerySyntax-Source.md).
# Effetti dell'eliminazione di una politica di indicizzazione dei campi
Se si elimina una politica di indicizzazione dei campi che è in vigore da un certo periodo, si verifica quanto segue:
+ Fino a 30 giorni dopo l'eliminazione della policy, le query possono ancora trarre vantaggio dagli eventi di registro indicizzati.
+ Se si elimina una politica di indicizzazione a livello di gruppo di log ed esiste già una politica a livello di account applicabile a quel gruppo di log, la politica a livello di account verrà infine applicata a quel gruppo di log.
# Usa le sfaccettature per raggruppare ed esplorare i log
I facet sono utili per analizzare i log in quanto consentono di filtrare e raggruppare i dati in modo interattivo senza eseguire query. Un facet è un campo nei log (ad esempio `ServiceName` or`StatusCode`) che consente il filtraggio, l'aggregazione e l'analisi tra gruppi di log. È possibile visualizzare l'elenco dei campi sfaccettati nella console CloudWatch Logs Insights, insieme al conteggio degli eventi di registro per ogni valore di facet in base all'intervallo di tempo selezionato. Quando selezioni sfaccettature e valori diversi, i valori e i conteggi delle sfaccettature vengono aggiornati in tempo reale, consentendoti di esplorare in modo interattivo i log.
Ogni sfaccettatura mostra i valori e i conteggi disponibili estratti automaticamente dai campi dei log in base all'intervallo di tempo e all'ambito della query selezionati e conservati per 30 giorni. I conteggi delle sfaccettature mostrati sono approssimativi. Puoi utilizzare i facet predefiniti, come il nome dell'origine dati o il tipo di origine dati, per esplorare i log o creare sfaccettature personalizzate su qualsiasi campo dei log. Data Source name è un servizio o un'applicazione AWS che genera i log (ad esempio, Route 53, Amazon VPC CloudTrail o) e il tipo Data Source è il tipo specifico di log generato da quel servizio. I facet predefiniti vengono creati CloudWatch e includono`@aws.region`,`@data_source_name`, `@data_source_type` e. `@data_format` Per ulteriori informazioni, consulta [Gestione dei registri](LogManagement.md). I facet sono disponibili solo per i log che vengono inseriti nell'account. Se hai impostato l'osservabilità tra account, l'account di monitoraggio non può visualizzare i facet in base ai log degli account di origine.
Per creare facet aggiuntivi, seleziona i campi nei log pertinenti alla risoluzione dei problemi e configurali utilizzando le politiche dell'indice. Per i facet personalizzati, consigliamo di crearli su campi a bassa cardinalità (campi con meno di 100 valori univoci al giorno come Status e). ApplicationName I facet con più di 100 valori univoci al giorno sono classificati come ad alta cardinalità e i relativi valori non vengono visualizzati. Seleziona uno o più facet e fai clic per eseguire query nei log.
Per iniziare a usare i facet in Logs Insights: CloudWatch
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**.
1. (Facoltativo) Utilizzate il selettore dell'intervallo di tempo per selezionare un periodo di tempo da analizzare. Per l'intervallo di tempo selezionato, le sfaccettature e i valori disponibili vengono visualizzati nel pannello.
1. Seleziona le sfaccettature per esplorare i dati e visualizzare gli aggiornamenti in tempo reale delle distribuzioni del valore tra le sfaccettature.
Le sfaccettature con più di 100 valori univoci non vengono visualizzate. Per interrogare valori specifici, utilizza invece i filtri nella query.
## Per eseguire una query basata su facet
1. Seleziona uno o più valori tra le sfaccettature.
1. Il conteggio degli eventi verrà aggiornato in base alle sfaccettature e ai valori selezionati.
1. Quando i valori delle sfaccettature vengono selezionati, l'ambito della query viene aggiornato in modo da riflettere la selezione.
1. Dopo aver selezionato i valori dei facet, fate clic su Esegui per eseguire la query.
1. Il numero massimo di valori univoci supportati per sfaccettatura è 100. Ad esempio, se sono presenti più di 100 valori per una sfaccettatura, tutti i conteggi vengono visualizzati come «-», a indicare che i valori sono sconosciuti.
## Per salvare un'interrogazione basata su facet
1. Crea la tua query utilizzando uno o più valori di sfaccettatura.
1. Il resto dei passaggi è lo stesso del salvataggio di una query di Logs Insights. Vedi [Salvare le interrogazioni di CloudWatch Logs Insights.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_Insights-Saving-Queries.html)
1. Le interrogazioni salvate sono disponibili nella sezione Interrogazioni salvate. Quando recuperi un'interrogazione salvata, questa includerà automaticamente i facet e i valori utilizzati per l'interrogazione, semplificando l'analisi dei log.
## Per creare un facet a livello di account
1. Per creare facet, devi prima creare il campo come indice e configurarlo come facet. Nel riquadro di navigazione, scegli **Impostazioni**, **Registri, Politiche** di indicizzazione a **livello di account**. In alternativa, puoi selezionare **Gestisci sfaccettature nel pannello** delle sfaccettature.
1. Scegliete **Crea nuova politica di indicizzazione**. Per i dettagli sulla creazione di politiche di indicizzazione, consulta[Crea una politica di indicizzazione dei campi a livello di account](CloudWatchLogs-Field-Indexing-CreateAccountLevel.md).
1. Per creare un facet, seleziona **Imposta come facet** per il campo selezionato nella pagina di creazione della politica dell'indice.
## Gestione delle sfaccettature utilizzando APIs
La gestione delle sfaccettature può essere eseguita utilizzando la politica dell'indice di campo. Per informazioni dettagliate, vedi [https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FieldIndex.html](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FieldIndex.html) APIs .
**Indice di campo APIs**
| No. | Nome | Description |
| --- | --- | --- |
| 1 | PutIndexPolicy | Crea o aggiorna una politica di indice dei campi per il gruppo di log specifico |
| 2 | PutAccountPolicy | Crea una politica di protezione dei dati a livello di account, una politica di filtro di abbonamento, una politica di indicizzazione dei campi, una politica di trasformazione o una politica di estrazione delle metriche che si applica a tutti i gruppi di log o a un sottoinsieme di gruppi di log nell'account |
| 3 | DeleteIndexPolicy | Elimina una politica di indice dei campi a livello di gruppo di log applicata a un singolo gruppo di log |
| 4 | DeleteAccountPolicy | Elimina una politica relativa all'account Logs CloudWatch |
# Analisi del modello
CloudWatch Logs Insights utilizza algoritmi di apprendimento automatico per trovare *modelli* quando esegui una query sui log. Un pattern è una struttura di testo condivisa che ricorre tra i campi di registro. Quando visualizzi i risultati di una query, puoi scegliere la scheda **Patterns** per vedere i modelli trovati da CloudWatch Logs in base a un campione dei tuoi risultati. In alternativa, è possibile aggiungere il `pattern` comando alla query per analizzare i modelli nell'intero set di eventi di registro corrispondenti.
I pattern sono utili per analizzare set di log di grandi dimensioni perché spesso un gran numero di eventi di log può essere compresso in pochi pattern.
Considerate il seguente esempio di tre eventi di registro.
```
2023-01-01 19:00:01 [INFO] Calling DynamoDB to store for resource id 12342342k124-12345
2023-01-01 19:00:02 [INFO] Calling DynamoDB to store for resource id 324892398123-12345
2023-01-01 19:00:03 [INFO] Calling DynamoDB to store for resource id 3ff231242342-12345
```
Nell'esempio precedente, tutti e tre gli eventi di registro seguono uno schema:
```
[INFO] Calling DynamoDB to store for resource id
```
I campi all'interno di un pattern sono chiamati *token.* *I campi che variano all'interno di uno schema, come l'ID della richiesta o il timestamp, sono token dinamici.* Ogni token dinamico è rappresentato da. `` *string*È una descrizione del tipo di dati rappresentato dal token. *number*Mostra dove nel modello appare questo token, rispetto agli altri token dinamici.
Esempi comuni di token dinamici includono codici di errore, timestamp e richieste. IDs Un *valore token* rappresenta un valore particolare di un token dinamico. Ad esempio, se un token dinamico rappresenta un codice di errore HTTP, il valore del token potrebbe essere`501`.
Il rilevamento dei pattern viene utilizzato anche nel rilevatore di anomalie CloudWatch Logs e nelle funzionalità di confronto. Per ulteriori informazioni, consultare [Rilevamento delle anomalie nei registri](LogsAnomalyDetection.md) e [Confronta (diff) con gli intervalli di tempo precedenti](CWL_AnalyzeLogData_Compare.md).
## Guida introduttiva all'analisi dei pattern
Il rilevamento dei pattern viene eseguito automaticamente in qualsiasi query di CloudWatch Logs Insights. Le query che non includono il `pattern` comando ottengono sia gli eventi che i modelli di registro nei risultati.
Se si include il `pattern` comando nella query, l'analisi dei pattern viene eseguita sull'intero set di eventi di registro corrispondenti. Ciò consente di ottenere risultati di pattern più accurati, ma gli eventi di log non elaborati non vengono restituiti quando si utilizza il `pattern` comando. Quando una query non include`pattern`, i risultati del modello si basano sui primi 1000 eventi di registro restituiti o sul valore limite utilizzato nella query. Se si include `pattern` nella query, i risultati visualizzati nella scheda **Patterns** derivano da tutti gli eventi di registro corrispondenti alla query.
**Per iniziare con l'analisi dei pattern in CloudWatch Logs 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**, quindi **Logs Insights**.
L'editor di query della pagina **Logs Insights** contiene una query predefinita che restituisce gli ultimi 20 log eventi.
1. Rimuovete la `| limit 20` riga nella casella di interrogazione, in modo che la query abbia il seguente aspetto:
```
fields @timestamp, @message, @logStream, @log
| sort @timestamp desc
```
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.
Puoi scegliere tra intervalli di 5 e 30 minuti, intervalli di 1 ora, 3 ore e 12 ore o un intervallo di tempo personalizzato.
1. Scegli **Esegui interrogazione per avviare** l'interrogazione.
Al termine dell'esecuzione della query, la scheda **Registri** visualizza una tabella degli eventi di registro restituiti dalla query. Sopra la tabella c'è un messaggio che indica quanti record corrispondono alla query, simile a **Mostra 10.000 record su 71.101** corrispondenti.
1. **Scegli la scheda Patterns.**
1. La tabella ora mostra i modelli trovati nella query. Poiché la query non includeva il `pattern` comando, questa scheda mostra solo i modelli rilevati tra i 10.000 eventi di registro mostrati nella tabella della scheda **Registri.**
Per ogni pattern, vengono visualizzate le seguenti informazioni:
+ Il **modello**, con ogni token dinamico visualizzato come``. *string*È una descrizione del tipo di dati rappresentato dal token. *number*Mostra dove nel modello appare questo token, rispetto agli altri token dinamici.
+ Il **conteggio degli eventi**, che è il numero di volte in cui il pattern è apparso negli eventi del registro interrogati. Scegli l'intestazione della colonna **Conteggio degli eventi** per ordinare i modelli in base alla frequenza.
+ Il **rapporto degli eventi**, che è la percentuale degli eventi di registro interrogati che contengono questo modello.
+ Il **tipo di severità**, che sarà uno dei seguenti:
+ **ERRORE** se il pattern contiene la parola **Error**.
+ **AVVISA** **se il pattern contiene la parola **Warn** ma non contiene Error.**
+ **INFO** **se il pattern non contiene né **Warn né Error.****
Scegli l'intestazione della colonna **Informazioni sulla gravità** per ordinare i modelli in base alla gravità.
1. Ora cambia la query. Sostituite la `| sort @timestamp desc` riga dell'interrogazione con`| pattern @message`, in modo che l'interrogazione completa sia la seguente:
```
fields @timestamp, @message, @logStream, @log
| pattern @message
```
1. Scegli **Esegui query**.
Al termine dell'interrogazione, non ci sono risultati nella scheda **Registri.** Tuttavia, è probabile che la scheda **Patterns** contenga un numero maggiore di pattern elencati, a seconda del numero totale di eventi di registro che sono stati interrogati.
1. Indipendentemente dal fatto che l'interrogazione sia stata inclusa `pattern` o meno, è possibile esaminare ulteriormente i pattern restituiti dalla query. A tale scopo, scegliete l'icona nella colonna **Ispeziona** per uno dei motivi.
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.
## Dettagli sul comando pattern
Questa sezione contiene ulteriori dettagli sul `pattern` comando e sui relativi utilizzi.
+ Nel tutorial precedente, abbiamo rimosso il `sort` comando quando l'abbiamo aggiunto `pattern` perché una query non è valida se include un `pattern` comando dopo un `sort` comando. È valido avere un `pattern` precedente a`sort`.
Per ulteriori dettagli sulla `pattern` sintassi, vedere[pattern](CWL_QuerySyntax-Pattern.md).
+ Quando si utilizza `pattern` in una query, `@message` deve essere uno dei campi selezionati nel `pattern` comando.
+ È possibile includere il `filter` comando prima di un `pattern` comando per fare in modo che solo l'insieme filtrato di eventi di registro venga utilizzato come input per l'analisi dei modelli.
+ Per visualizzare i risultati del pattern per un campo particolare, ad esempio un campo derivato dal `parse` comando, usa`pattern @fieldname`.
+ Le query con output non di registro, ad esempio le query con il `stats` comando, non restituiscono risultati di pattern.
# Salva ed esegui nuovamente le query di Logs Insights CloudWatch
Dopo aver creato una query, è possibile salvarla in modo da poterla eseguire di nuovo in un secondo momento. Le interrogazioni vengono salvate in una struttura di cartelle, in modo da poterle organizzare. Puoi salvare fino a 1000 query per regione per account.
Le interrogazioni vengono salvate a un livello specifico della regione, non a un livello specifico dell'utente. Se si crea e si salva un'interrogazione, gli altri utenti con accesso ai CloudWatch registri nella stessa area possono visualizzare tutte le interrogazioni salvate e le relative strutture di cartelle nella regione.
Per salvare una query, è necessario accedere a un ruolo che dispone dell'autorizzazione `logs:PutQueryDefinition`. Per visualizzare un elenco di query salvate, è necessario accedere a un ruolo che dispone dell'autorizzazione `logs:DescribeQueryDefinitions`.
**Nota**
È possibile creare e salvare interrogazioni con parametri, ovvero modelli riutilizzabili con segnaposto denominati. Invece di salvare più varianti della stessa interrogazione con valori diversi, create un modello e fornite valori di parametro diversi quando lo eseguite. Questa funzionalità è attualmente supportata solo per le query che utilizzano il linguaggio di query Logs Insights. Per ulteriori informazioni, vedere [Utilizzo delle interrogazioni salvate con](#CWL_Insights-Parameterized-Queries) parametri.
------
#### [ Console ]
**Per salvare un'interrogazione**
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'editor di query, crea una query.
1. Scegli **Save** (Salva).
1. Immettere un nome per la query.
1. (Facoltativo) Scegliere una cartella in cui si desidera salvare la query. Selezionare **Create new (Crea nuova)** per creare una cartella. Se si crea una nuova cartella, è possibile utilizzare i caratteri barra (/) nel nome della cartella per definire una struttura di cartelle. Ad esempio, la denominazione di una nuova cartella **folder-level-1/folder-level-2** crea una cartella di livello superiore denominata **folder-level-1**, con un'altra cartella chiamata **folder-level-2** all'interno di tale cartella. La query viene salvata in **folder-level-2**.
1. (Facoltativo) Modificare i gruppi di log o il testo della query.
1. (Facoltativo) Per utilizzare i parametri nella query, segui questi passaggi aggiuntivi:
1. **Aggiungi parametri alla tua query.** Sostituisci i valori statici con segnaposto utilizzando la `{{parameter}}` sintassi (doppie parentesi prima e dopo il nome del parametro).
Esempio: interrogazione originale con valori statici:
```
fields @timestamp, @message
| filter level = "Error"
| filter applicationName = "OrderService"
```
Interrogazione aggiornata con parametri:
```
fields @timestamp, @message
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
```
1. **Definire i parametri utilizzati nella query.** Per ogni parametro segnaposto, specificate:
+ **Nome**: deve corrispondere esattamente al nome del segnaposto (ad esempio,). `logLevel` `applicationName`
+ **Valore predefinito** (opzionale): il valore da utilizzare se non viene fornito alcun valore di parametro.
+ **Descrizione** (opzionale): spiega lo scopo del parametro.
1. Le interrogazioni con parametri possono essere eseguite utilizzando il nome della query con un `$` prefisso e passando i nomi dei parametri come coppie chiave-valore. **Per ulteriori informazioni, vedere Eseguire un'interrogazione salvata**.
1. Scegli **Save** (Salva).
------
#### [ AWS CLI ]
**Per salvare un'interrogazione**, usa`put-query-definition`:
```
aws logs put-query-definition \
--name "ErrorsByLevel" \
--query-string "fields @timestamp, @message | filter level = \"ERROR\"" \
--log-group-names "/aws/lambda/my-function" \
--region us-east-1
```
(Facoltativo) Per salvare un'interrogazione con parametri, aggiungete l'`--parameters`opzione e utilizzate i `{{parameterName}}` segnaposto nella stringa di query:
```
aws logs put-query-definition \
--name "ErrorsByLevel" \
--query-string "fields @timestamp, @message | filter level = {{logLevel}} | filter applicationName = {{applicationName}}" \
--parameters '[{"name":"logLevel","defaultValue":"ERROR","description":"Log level to filter"},{"name":"applicationName","defaultValue":"OrderService","description":"Application name to filter"}]' \
--log-group-names "/aws/lambda/my-function" \
--region us-east-1
```
Per salvare un'interrogazione in una cartella, aggiungete il percorso della cartella come prefisso al nome della query:
```
aws logs put-query-definition \
--name "my-folder/ErrorsByLevel" \
--query-string "fields @timestamp, @message | filter level = {{logLevel}}" \
--parameters '[{"name":"logLevel","defaultValue":"ERROR","description":"Log level to filter"}]' \
--log-group-names "/aws/lambda/my-function" \
--region us-east-1
```
------
#### [ API ]
**Per salvare un'interrogazione**, chiama [PutQueryDefinition](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutQueryDefinition.html):
```
{
"name": "ErrorsByLevel",
"queryString": "fields @timestamp, @message | filter level = \"ERROR\"",
"logGroupNames": ["/aws/lambda/my-function"]
}
```
(Facoltativo) Per salvare un'interrogazione con parametri, includete il `parameters` campo e utilizzate i `{{parameterName}}` segnaposto nella stringa di query:
```
{
"name": "ErrorsByLevel",
"queryString": "fields @timestamp, @message | filter level = {{logLevel}} | filter applicationName = {{applicationName}}",
"logGroupNames": ["/aws/lambda/my-function"],
"parameters": [
{
"name": "logLevel",
"defaultValue": "ERROR",
"description": "Log level to filter"
},
{
"name": "applicationName",
"defaultValue": "OrderService",
"description": "Application name to filter"
}
]
}
```
------
**Suggerimento**
Puoi creare una cartella per le query salvate con`PutQueryDefinition`. Per creare una cartella per le query salvate, utilizza una barra (/) per anteporre al nome della query desiderata il nome della cartella: `/`. Per ulteriori informazioni su questa azione, vedere. [PutQueryDefinition](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutQueryDefinition.html)
------
#### [ Console ]
**Per eseguire una query salvata**
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. A destra, scegliere **Query**.
1. Seleziona la tua interrogazione dall'elenco **Interrogazioni salvate**. Il testo della query viene visualizzato nell'editor delle query.
1. (Facoltativo) Per utilizzare un'interrogazione con parametri:
1. Scegli l'icona **\$1** accanto al nome dell'interrogazione nel pannello laterale **Interrogazioni salvate**.
1. L'interrogazione con parametri viene visualizzata nell'editor delle interrogazioni. Ad esempio, se si sceglie l'icona **\$1** accanto a`ErrorsByLevel`, l'editor di query viene popolato con: `$ErrorsByLevel(level=, applicationName=)`
1. Fornire i valori per i parametri (level, ApplicationName) ed eseguire la query. Ad esempio: `$ErrorsByLevel(level= "ERROR", applicationName= "OrderService")`
1. Scegli **Esegui**.
------
#### [ AWS CLI ]
**Per eseguire un'interrogazione salvata con parametri**
Utilizzare `start-query` con la `$QueryName()` sintassi:
```
aws logs start-query \
--log-group-names "/aws/lambda/my-function" \
--start-time 1707566400 --end-time 1707570000 \
--query-string '$ErrorsByLevel(level= "ERROR", applicationName= "OrderService")' \
--region us-east-1
```
------
#### [ API ]
**Per eseguire un'interrogazione salvata con parametri**
Chiama [StartQuery](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html)con la `$QueryName()` sintassi presente nel `queryString` campo:
```
{
"logGroupNames": ["/aws/lambda/my-function"],
"startTime": 1707566400,
"endTime": 1707570000,
"queryString": "$ErrorsByLevel(level=\"ERROR\", applicationName= \"OrderService\")"
}
```
------
**Per salvare una nuova versione di una query salvata**
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. A destra, scegliere **Query**.
1. Selezionare la query dall'elenco **Saved queries (Query salvate)**. Viene visualizzata nell'editor di query.
1. Modificare la query. Se è necessario eseguire la query per controllare il proprio lavoro, scegliere **Run query (Esegui query)**.
1. Quando si è pronti per salvare la nuova versione, scegliere **Actions (Operazioni)**, **Save as (Salva con nome)**.
1. Immettere un nome per la query.
1. (Facoltativo) Scegliere una cartella in cui si desidera salvare la query. Selezionare **Create new (Crea nuova)** per creare una cartella. Se si crea una nuova cartella, è possibile utilizzare i caratteri barra (/) nel nome della cartella per definire una struttura di cartelle. Ad esempio, la denominazione di una nuova cartella **folder-level-1/folder-level-2** crea una cartella di livello superiore denominata **folder-level-1**, con un'altra cartella chiamata **folder-level-2** all'interno di tale cartella. La query viene salvata in **folder-level-2**.
1. (Facoltativo) Modificare i gruppi di log o il testo della query.
1. Scegli **Save** (Salva).
Per eliminare una query, è necessario accedere a un ruolo che dispone dell'autorizzazione `logs:DeleteQueryDefinition`.
**Per modificare o eliminare una query salvata**
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. A destra, scegliere **Query**.
1. Selezionare la query dall'elenco **Saved queries (Query salvate)**. Viene visualizzata nell'editor di query.
1. Scegliere **Actions (Operazioni)**, **Edit (Modifica)** oppure **Actions (Operazioni)**, **Delete (Elimina)**.
## Utilizzo di interrogazioni salvate con parametri
Le interrogazioni salvate con parametri sono modelli di query riutilizzabili con segnaposto denominati. Invece di conservare più copie di interrogazioni quasi identiche, è possibile salvare un modello e fornire valori di parametro diversi durante l'esecuzione della query. I parametri sono supportati solo nel linguaggio di interrogazione CloudWatch Logs Insights.
**Come funziona**
Quando si salva un'interrogazione, i segnaposto identificano i valori che è possibile fornire al momento dell'esecuzione della query. I segnaposti utilizzano la sintassi. `{{parameterName}}` Di seguito è riportato un esempio di interrogazione salvata denominata `ErrorsByLevel` con due parametri e. `logLevel` `applicationName`
```
fields @timestamp, @message
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
```
Per eseguire un'interrogazione salvata, è possibile richiamarla utilizzando il nome dell'interrogazione preceduto da `$` e passando i valori dei parametri. Il motore di query CloudWatch Logs Insights sostituisce ogni segnaposto. Se un parametro contiene valori predefiniti, tali valori vengono utilizzati se non vengono forniti altri valori.
```
# Run query by using query name and passing parameter values explicitly
$ErrorsByLevel(logLevel = "WARN", applicationName = "OrderService")
# Run query without specifying parameter values - default values are used in this case.
$ErrorsByLevel()
```
I nomi delle interrogazioni salvate contenenti spazi o caratteri speciali devono essere racchiusi tra segni di spunta inversa:
```
$`Errors By Level`(logLevel = "WARN")
```
### Esempi di interrogazioni salvate con parametri
**Aggiungere un limite di risultati come parametro**
Nome della query: `ErrorsByLevel` con parametri `logLevel` (default:`"ERROR"`), `applicationName` (default:`"OrderService"`) e `maxResults` (default:`50`)
```
fields @timestamp, @message, @logStream
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
| sort @timestamp desc
| limit {{maxResults}}
```
```
# Run the query using the query name and passing parameter values
$ErrorsByLevel(logLevel = "WARN", applicationName = "OrderService", maxResults = 100)
```
**Utilizzo di più interrogazioni salvate con parametri**
L'esempio seguente utilizza `ErrorsByLevel` una seconda query salvata `RecentN` che è definita come `sort @timestamp desc | limit {{count}}` (con parametro`count`, impostazione predefinita`20`). Il motore di query CloudWatch Logs Insights espande ogni query prima di eseguirla.
```
# Using multiple queries with parameters in sequence
$ErrorsByLevel(logLevel = "WARN", applicationName = "OrderService")
| $RecentN(count = 10)
# Each of the queries is expanded, resulting in the following query when it is run.
fields @timestamp, @message
| filter level = "WARN"
| filter applicationName = "OrderService"
| sort @timestamp desc
| limit 10
```
### Quote e gestione degli errori
**Nota**
Ogni interrogazione salvata può avere un massimo di 20 parametri.
La stringa di query espansa non può superare i 10.000 caratteri. I nomi dei parametri devono iniziare con una lettera o un carattere di sottolineatura. Un'interrogazione salvata non può fare riferimento a un'altra interrogazione salvata (le chiamate annidate non sono supportate).
**Errori comuni**
| Errore | Causa |
| --- | --- |
| I parametri sono supportati solo per il linguaggio di interrogazione CWLI | I parametri sono supportati solo nel linguaggio di query CloudWatch Logs Insights. |
| Parametri obbligatori non trovati in QueryString | Il nome di un parametro in `--parameters` non ha una corrispondenza `{{placeholder}}` nella stringa di query. |
| Il numero di parametri supera il massimo di 20 | Le interrogazioni salvate attualmente supportano solo 20 parametri. |
| Nome di parametro duplicato | La definizione della query contiene parametri duplicati. `parameters` |
**Nota**
Per creare o aggiornare un'interrogazione salvata con parametri, è necessaria l'`logs:PutQueryDefinition`autorizzazione. Per eseguirne una, è necessario `logs:StartQuery` e`logs:DescribeQueryDefinitions`.
# Aggiunta di query a pannello di controllo o esportazione dei risultati della query
Dopo aver eseguito una query, puoi aggiungere la query a un CloudWatch pannello di controllo o copiare i risultati negli Appunti.
Le query aggiunte ai pannelli di controllo vengono eseguite ogni volta che carichi il pannello di controllo e ogni volta che il pannello di controllo viene aggiornato. Queste query vengono conteggiate ai fini del limite di 100 query simultanee di Logs Insights CloudWatch .
**Per aggiungere i risultati delle query a un pannello di controllo**
1. Apri la console all'indirizzo. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel pannello di navigazione scegli **Logs** (Registri), quindi **Logs Insights**.
1. Scegli uno o più gruppi di log ed esegui una query.
1. Scegli **Add to dashboard (Aggiungi a pannello di controllo)**.
1. Seleziona il pannello di controllo, oppure scegli **Create new (Crea nuovo)** per creare un pannello di controllo per i risultati delle query.
1. Seleziona il tipo di widget da utilizzare per i risultati della query.
1. Inserisci un nome per il widget.
1. Scegli **Add to dashboard (Aggiungi a pannello di controllo)**.
**Per copiare i risultati della query negli appunti o scaricare i risultati della query**
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. Scegli uno o più gruppi di log ed esegui una query.
1. Scegli **Export results (Esporta risultati)**, quindi scegli l'opzione desiderata.
# Visualizzazione di query in esecuzione o cronologia delle query
Puoi visualizzare le query attualmente in corso, nonché la cronologia delle query recenti.
Le query attualmente in esecuzione includono quelle aggiunte a un pannello di controllo. Hai un limite di 100 query simultanee di CloudWatch Logs Insights per account, incluse le query aggiunte ai dashboard. Inoltre, è possibile eseguire 15 query simultanee per Service PPL o Service SQL. OpenSearch OpenSearch
**Per visualizzare la cronologia delle query recenti**
1. Apri la console all' CloudWatch 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. Scegli **Cronologia**, se stai usando il nuovo design per la console CloudWatch Logs. Se utilizzi il vecchio design, scegli **Actions (Operazioni)**, **View query history for this account (Visualizza cronologia query per questo account)**.
Viene visualizzato un elenco delle query recenti. Puoi eseguire di nuovo qualsiasi query selezionandola e scegliendo **Run (Esegui)**.
In **Stato**, viene visualizzato il CloudWatch messaggio Registri **in corso** per tutte le interrogazioni attualmente in esecuzione.
# Crittografa i risultati delle interrogazioni con AWS Key Management Service
Per impostazione predefinita, CloudWatch Logs crittografa i risultati archiviati delle query di CloudWatch Logs Insights utilizzando il metodo di crittografia predefinito Logs lato server. CloudWatch Puoi invece scegliere di utilizzare una chiave per crittografare questi risultati AWS KMS . Se associ una AWS KMS chiave ai risultati della crittografia, CloudWatch Logs utilizza quella chiave per crittografare i risultati archiviati di tutte le query nell'account.
Se successivamente si dissocia una chiave dai risultati della query, CloudWatch Logs torna al metodo di crittografia predefinito per le query successive. Tuttavia, le query eseguite mentre la chiave era associata sono ancora crittografate con quella chiave. CloudWatch I log possono comunque restituire quei risultati dopo che la chiave KMS è stata dissociata, perché CloudWatch i log possono continuare a fare riferimento alla chiave. Tuttavia, se la chiave viene successivamente disabilitata, CloudWatch Logs non è in grado di leggere i risultati della query che sono stati crittografati con quella chiave.
**Importante**
CloudWatch Logs supporta solo chiavi KMS simmetriche. Non utilizzare una chiave asimmetrica per crittografare i risultati della query. Per ulteriori informazioni, consulta la sezione relativa all'[uso di chiavi simmetriche e asimmetriche](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html).
## Limits
+ Per eseguire la procedura seguente, devi avere le seguenti autorizzazioni: `kms:CreateKey`, `kms:GetKeyPolicy` e `kms:PutKeyPolicy`.
+ Dopo aver associato o dissociato una chiave dai risultati della query, possono essere necessari fino a cinque minuti per rendere effettiva l'operazione.
+ Se CloudWatch revochi l'accesso dei log a una chiave associata o elimini una chiave KMS associata, i dati crittografati in Logs non possono più essere recuperati. CloudWatch
+ Non puoi utilizzare la CloudWatch console per associare una chiave, devi utilizzare l'API o Logs. AWS CLI CloudWatch
## Passaggio 1: creare un AWS KMS key
Per creare una chiave KMS, utilizza il seguente comando [create-key](https://docs.aws.amazon.com/cli/latest/reference/kms/create-key.html):
```
aws kms create-key
```
L'output contiene l'ID chiave e l'Amazon Resource Name (ARN) della chiave. Di seguito è riportato un output di esempio:
```
{
"KeyMetadata": {
"Origin": "AWS_KMS",
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"Description": "",
"KeyManager": "CUSTOMER",
"Enabled": true,
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"KeyUsage": "ENCRYPT_DECRYPT",
"KeyState": "Enabled",
"CreationDate": 1478910250.94,
"Arn": "arn:aws:kms:us-west-2:123456789012:key/6f815f63-e628-448c-8251-e40cb0d29f59",
"AWSAccountId": "123456789012",
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
]
}
}
```
## Fase 2: Impostazione delle autorizzazioni sulla chiave KMS
Per impostazione predefinita, tutte le chiavi KMS sono private. Solo il proprietario della risorsa può utilizzarla per crittografare e decrittare i dati. Tuttavia, il proprietario della risorsa può concedere ad altri utenti e risorse le autorizzazioni per accedere alla chiave. Con questo passaggio, si CloudWatch concede al servizio Logs l'autorizzazione principale a utilizzare la chiave. L'entità del servizio deve trovarsi nella stessa AWS regione in cui è memorizzata la chiave.
Come procedura ottimale, si consiglia di limitare l'uso della chiave solo agli AWS account specificati.
Innanzitutto, salva la politica predefinita per la tua chiave KMS `policy.json` utilizzando il seguente [get-key-policy](https://docs.aws.amazon.com/cli/latest/reference/kms/get-key-policy.html)comando:
```
aws kms get-key-policy --key-id key-id --policy-name default --output text > ./policy.json
```
Aprire il file `policy.json` in un editor di testo e aggiungere la sezione in grassetto da una delle seguenti istruzioni. Separare l'istruzione esistente dalla nuova istruzione con una virgola. Queste istruzioni utilizzano `Condition` le sezioni per migliorare la sicurezza della AWS KMS chiave. Per ulteriori informazioni, consulta [AWS KMS chiavi e contesto di crittografia](encrypt-log-data-kms.md#encrypt-log-data-kms-policy).
La `Condition` sezione di questo esempio limita l'uso della AWS KMS chiave ai risultati della query CloudWatch Logs Insights nell'account specificato.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "key-default-1",
"Statement": [
{
"Sid": "Enable IAM User Permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Effect": "Allow",
"Principal": {
"Service": "logs.region.amazonaws.com"
},
"Action": [
"kms:Encrypt*",
"kms:Decrypt*",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:Describe*"
],
"Resource": "*",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:logs:us-east-1:111122223333:query-result:*"
},
"StringEquals": {
"aws:SourceAccount": "111122223333"
}
}
}
]
}
```
------
Infine, aggiungi la politica aggiornata utilizzando il seguente [put-key-policy](https://docs.aws.amazon.com/cli/latest/reference/kms/put-key-policy.html)comando:
```
aws kms put-key-policy --key-id key-id --policy-name default --policy file://policy.json
```
## Fase 3: associazione di una chiave KMS ai risultati della query
**Associazione della chiave KMS ai risultati della query nell'account**
Utilizza il comando [disassociate-kms-key](https://docs.aws.amazon.com/cli/latest/reference/logs/disassociate-kms-key.html) come segue:
```
aws logs associate-kms-key --resource-identifier "arn:aws:logs:region:account-id:query-result:*" --kms-key-id "key-arn"
```
## Fase 4: Dissociazione di una chiave dai risultati della query nell'account
Per dissociare la chiave KMS associata ai risultati della query, usa il seguente [disassociate-kms-key](https://docs.aws.amazon.com/cli/latest/reference/logs/disassociate-kms-key.html)comando:
```
aws logs disassociate-kms-key --resource-identifier "arn:aws:logs:region:account-id:query-result:*"
```
# Genera un riepilogo in linguaggio naturale dai risultati delle query di CloudWatch Logs Insights
L'analisi dei dati di registro è fondamentale per comprendere il comportamento delle applicazioni, ma l'interpretazione di grandi volumi di voci di registro può richiedere molto tempo. CloudWatch Logs Insights offre ora una funzionalità di riepilogo in linguaggio naturale che trasforma i risultati di query complesse in riepiloghi chiari e concisi. Questa funzionalità consente di identificare rapidamente i problemi e ottenere informazioni utili dai dati di registro.
## Come funziona
CloudWatch Logs Insights può generare un riepilogo leggibile dai risultati delle tue query utilizzando Amazon Bedrock. La funzionalità supporta tutti i linguaggi di interrogazione di CloudWatch Logs Insights e fornisce informazioni chiare e fruibili a partire dai dati di log.
## Disponibilità regionale ed elaborazione dei dati
**Importante**
Quando si utilizza questa funzionalità, i risultati della query potrebbero essere elaborati in un modo diverso Regione AWS. Ad esempio, se si esegue una query negli Stati Uniti orientali (Virginia settentrionale), il riepilogo potrebbe avvenire negli Stati Uniti occidentali (Oregon).
La tabella seguente elenca l'elaborazione possibile Regione AWS per le diverse aree geografiche in cui è disponibile la funzionalità dei risultati delle query:
| Geografia dei log supportata CloudWatch | Regione di elaborazione possibile |
| --- | --- |
| Stati Uniti (US) | Stati Uniti orientali (Virginia settentrionale) US East (Ohio) Region US West (Oregon) Region |
| Europa | Regione Europa (Francoforte) Regione Europa (Irlanda) Regione Europa (Parigi) Regione Europa (Stoccolma) Regione Europa (Londra) |
| Asia Pacifico | Stati Uniti orientali (Virginia settentrionale) US East (Ohio) Region US West (Oregon) Region |
| Sud America | Stati Uniti orientali (Virginia settentrionale) US East (Ohio) Region US West (Oregon) Region |
## Nozioni di base
**Per generare un riepilogo in linguaggio naturale**
1. Esegui la tua query CloudWatch Logs Insights.
1. Al termine della query, seleziona **Riassumi** i risultati.
## Permissions
È necessario disporre di una delle seguenti opzioni:
+ Autorizzazione `CloudWatchLogsFullAccess`
+ Autorizzazione `CloudWatchLogsReadOnlyAccess`
+ Policy IAM personalizzata che include le `cloudwatch:GenerateQueryResultsSummary` `logs:FilterLogEvents` azioni `logs:DescribeQueries` e `logs:GetQueryResults`
## Privacy dei dati
I risultati delle query vengono elaborati in modo sicuro e non vengono utilizzati per addestrare o migliorare CloudWatch Logs Insights o Amazon Bedrock. Se scegli di fornire un feedback sul riepilogo dei risultati della query utilizzando i pulsanti di feedback, il feedback indica il tuo livello di soddisfazione rispetto alla funzionalità fornita in CloudWatch Logs Insights.