Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Trasforma i log durante l'ingestione
Con la trasformazione e l'arricchimento dei log, puoi normalizzare tutti i log in un formato coerente e ricco di contesto al momento dell'inserimento in Logs. CloudWatch [Puoi aggiungere una struttura ai tuoi log utilizzando modelli preconfigurati per AWS servizi comuni come AWS WAF Amazon Route 53 o creare trasformatori personalizzati con parser nativi come Grok.](CloudWatch-Logs-Transformation-Configurable.md#CloudWatch-Logs-Transformation-Grok) Puoi anche rinominare gli attributi esistenti e aggiungere metadati aggiuntivi ai log, come l'ID dell'account e la regione.
La trasformazione dei log aiuta a semplificare e abbreviare le query di registro tra le applicazioni e aiuta a semplificare la creazione di avvisi sui log. Questa funzionalità fornisce la trasformazione per i tipi di log più comuni con modelli di out-of-the-box trasformazione per le principali fonti di AWS log come i log di flusso VPC, Route 53 e. Amazon RDS for PostgreSQL Puoi utilizzare modelli di trasformazione preconfigurati o creare trasformatori personalizzati per soddisfare le tue esigenze.
La trasformazione dei registri consente di gestire i log emessi da varie fonti che variano notevolmente nel formato e nei nomi degli attributi.
Dopo aver creato un trasformatore, gli eventi di registro importati vengono convertiti e archiviati in un formato standard. Puoi sfruttare questi log trasformati per accelerare la tua esperienza di analisi con le seguenti funzionalità:
+ [Indici di campo](CloudWatchLogs-Field-Indexing.md)
+ [CloudWatch Campi rilevati da Logs Insights](CWL_AnalyzeLogData-discoverable-fields.md)
+ [Flessibilità nell'invio di allarmi utilizzando filtri metrici](MonitoringLogData.md)
+ [Inoltro tramite filtri di abbonamento](Subscriptions.md)
+ Creazione di dati metrici dagli eventi di registro con [Contributor Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContributorInsights.html), dove puoi scegliere di fare in modo che la regola Contributor Insights valuti gli eventi di registro prima o dopo la loro trasformazione.
Le trasformazioni avvengono solo durante l'inserimento dei log. Non è possibile trasformare gli eventi di registro che sono già stati inseriti. Le trasformazioni non sono reversibili. Sia i log originali che quelli trasformati vengono archiviati in CloudWatch Log con la stessa politica di conservazione. La funzionalità di trasformazione e arricchimento dei log è inclusa nel prezzo di inserimento della classe di log Standard esistente. I costi di archiviazione dei log si baseranno sulla dimensione del registro dopo la trasformazione, che potrebbe superare il volume di log originale.
**Importante**
Dopo la trasformazione degli eventi di registro, è necessario utilizzare le query di CloudWatch Logs Insights per visualizzare le versioni trasformate dei log. Le [ FilterLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FilterLogEvents.html)azioni [ GetLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogEvents.html)and restituiscono solo le versioni originali degli eventi di registro, prima che venissero trasformati.
**Importante**
Nonostante un singolo evento di registro PutLogEvents consenta fino a 1 MB, la trasformazione dei log può gestire solo eventi di registro di dimensioni inferiori a 512 kb. Qualsiasi evento di registro superiore a 512 kb fallirà nella trasformazione e genererà un errore. La dimensione totale di PutLogEvents può comunque superare i 512 kb.
Oltre a trasformarli in diversi formati, puoi anche arricchire i tuoi log con un contesto aggiuntivo, come l'ID dell'account, la regione e la parola chiave. Questi vengono estratti dal nome del gruppo di log e dalle parole chiave statiche.
La trasformazione dei log ti aiuta con i log emessi da varie fonti che variano notevolmente nel formato e nei nomi degli attributi.
La trasformazione e l'arricchimento dei log sono supportati solo per i gruppi di log nella classe di log Standard.
Puoi creare trasformatori per singoli gruppi di log e puoi anche creare trasformatori a livello di account che si applicano a tutti o a molti gruppi di log del tuo account. Se un gruppo di log ha un trasformatore a livello di gruppo di log, tale trasformatore sostituisce qualsiasi trasformatore a livello di account che altrimenti si applicherebbe a quel gruppo di log.
**Topics**
+ [Crea e gestisci trasformatori di log](CloudWatch-Logs-Transformation-Create.md)
+ [Processori configurabili di tipo parser](CloudWatch-Logs-Transformation-Configurable.md)
+ [Processori integrati per i AWS log venduti](CloudWatch-Logs-Transformation-BuiltIn.md)
+ [Processori di mutazione delle stringhe](CloudWatch-Logs-Transformation-StringMutate.md)
+ [Processori JSON con mutazione](CloudWatch-Logs-Transformation-JSONMutate.md)
+ [Processori di conversione di tipi di dati](CloudWatch-Logs-Transformation-Datatype.md)
+ [Metriche ed errori di trasformazione](Transformation-Errors-Metrics.md)
# Crea e gestisci trasformatori di log
Un trasformatore di log include uno o più *processori* che si trovano insieme in una pipeline logica. Ogni processore viene applicato a un evento di registro, uno dopo l'altro nell'ordine in cui sono elencati nella configurazione del trasformatore.
Alcuni processori sono del tipo *parser*. Ogni trasformatore deve avere almeno un parser e il primo processore di un trasformatore deve essere un parser.
Alcuni parser sono parser integrati configurati per un determinato tipo di log fornito. AWS
Altri tipi di processori sono i mutatori di stringa, i mutatori JSON e i processori di dati.
Puoi creare trasformatori per singoli gruppi di log e puoi anche creare trasformatori a livello di account che si applicano a tutti o a molti gruppi di log del tuo account. Se un gruppo di log ha un trasformatore a livello di gruppo di log, tale trasformatore sostituisce qualsiasi trasformatore a livello di account che altrimenti si applicherebbe a quel gruppo di log. Nel tuo account puoi avere fino a 20 trasformatori a livello di account in una regione.
È necessario seguire queste linee guida quando si crea un trasformatore:
+ Se includete un parser preconfigurato per un tipo di log AWS forniti, deve essere il primo processore elencato nel trasformatore. È possibile includere solo un processore di questo tipo in un trasformatore.
+ È possibile includere un solo `grok` processore in un trasformatore.
+ È necessario disporre di almeno un processore di tipo parser in un trasformatore. È possibile includere fino a cinque processori di tipo parser. Questo limite di cinque include sia i parser integrati che i parser configurabili.
+ È possibile avere fino a 20 processori in un trasformatore.
+ È possibile includere un solo processore **AddKeys** in un trasformatore.
+ È possibile includere un solo processore **CopyValue** in un trasformatore.
+ Ogni trasformatore può estrarre fino a 200 campi da un evento di registro.
+ Ogni evento di registro **DEVE** essere inferiore a 512 KB. La dimensione totale degli eventi di registro può comunque superare i 512 KB.
**Topics**
+ [Crea una politica di trasformazione a livello di account](CloudWatchLogs-Transformer-CreateAccountLevel.md)
+ [Modifica o elimina una politica di trasformazione a livello di account](CloudWatchLogs-Transformer-EditAccountLevel.md)
+ [Crea un trasformatore di log-group-level log partendo da zero](CloudWatch-Logs-Transformation-CreateNew.md)
+ [Crea un log-group-level trasformatore copiandone uno esistente](CloudWatch-Logs-Transformation-Copy.md)
+ [Modifica un trasformatore log-group-level](CloudWatch-Logs-Transformation-Edit.md)
+ [Eliminare un trasformatore log-group-level](CloudWatch-Logs-Transformation-Delete.md)
# Crea una politica di trasformazione a livello di account
Utilizza i passaggi di questa sezione per creare una politica di trasformazione 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 (prefisso). È possibile avere fino a 20 politiche di trasformazione a livello di account in una regione.
Non è possibile creare due politiche di trasformazione nella stessa regione che utilizzano lo stesso prefisso o che hanno un prefisso contenuto all'interno di un altro. Ad esempio, se create una politica di trasformazione per il prefisso di stringa`/aws/lambda`, non potete crearne un'altra con il prefisso. `/aws` Ma potresti avere un trasformatore per e un altro per `/aws/lambda` `/aws/waf`
**Per creare una politica di trasformazione a livello di account**
1. Apri la console all' CloudWatch 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 **Transformer policy for account**, scegli **Crea policy Transformer**.
1. Per il **nome della politica Transformer**, inserisci un nome per la tua nuova politica.
1. Per **Select log groups**, effettuate una delle seguenti operazioni:
+ Scegliete **Tutti i gruppi di log standard** per applicare la politica del trasformatore a tutti i gruppi di log 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 tutti con la stessa stringa. **Quindi, inserisci il prefisso per questi gruppi di log in Criteri di selezione.**
1. Nell'area **Seleziona parser, usa Parsers** **per selezionare un parser** da includere nel tuo trasformatore.
Se si tratta di un parser preconfigurato per un tipo di registro AWS fornito, non è necessario specificare alcuna configurazione.
Se si tratta di un parser diverso, è necessario specificarne la configurazione. Per ulteriori informazioni, consulta le informazioni relative al processore in[Processori configurabili di tipo parser](CloudWatch-Logs-Transformation-Configurable.md).
1. Per aggiungere un altro processore, scegli **Seleziona processore**. Quindi seleziona il processore che desideri nella casella **Processore** e inserisci i parametri di configurazione.
Ricordate che i processori operano sugli eventi di registro nell'ordine in cui li aggiungete al trasformatore.
1. (Facoltativo) Per aggiungere processori aggiuntivi, scegliete **\$1 Processore** e ripetete il passaggio precedente.
1. (Facoltativo) In qualsiasi momento, potete testare il trasformatore che avete creato finora sulla base di un evento di registro di esempio. A tale scopo, effettuate una delle seguenti operazioni nella sezione di **anteprima di Transformer**:
+ Seleziona fino a cinque gruppi di log in **Seleziona gruppi di log**, quindi scegli **Carica gli ultimi eventi di registro**. Quindi scegli **Test transformer**.
+ Copia gli eventi di registro direttamente in **Sample log events**, quindi scegli **Test transformer**.
Viene quindi visualizzata la versione trasformata del registro.
1. Quando hai finito di aggiungere processori e sei soddisfatto dei test sui log di esempio, scegli **Salva**.
1. Al termine, scegliere **Create (Crea)**.
# Modifica o elimina una politica di trasformazione a livello di account
Utilizza i passaggi di questa sezione per modificare o eliminare una politica di trasformazione a livello di account.
**Per modificare o eliminare una politica di trasformazione a livello di account**
1. Apri la console all' CloudWatch 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 **Politica dell'account Transformer**, scegli Gestisci.**
1. **Seleziona il pulsante accanto alla politica del trasformatore che desideri gestire, quindi scegli **Modifica o Elimina**.**
Se stai modificando la politica, consulta i passaggi da 5 a 11 [Processori configurabili di tipo parser](CloudWatch-Logs-Transformation-Configurable.md) per vedere le opzioni a tua disposizione.
# Crea un trasformatore di log-group-level log partendo da zero
Usa questi passaggi per creare un log-group-level trasformatore da zero.
**Per utilizzare la console per creare un trasformatore di log per un 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 **Log**, **Gruppi di log**.
1. Scegli il gruppo di log per cui vuoi creare il trasformatore.
1. Scegli la scheda **Transformer**. Potrebbe essere necessario scorrere l'elenco delle schede verso destra per visualizzarlo.
1. Scegli **Crea trasformatore**.
1. Nella casella **Scegli un parser**, seleziona un parser da includere nel tuo trasformatore.
Se si tratta di un parser preconfigurato per un tipo di AWS registro fornito, non è necessario specificare alcuna configurazione.
Se si tratta di un parser diverso, è necessario specificarne la configurazione. Per ulteriori informazioni, consulta le informazioni relative al processore in[Processori configurabili di tipo parser](CloudWatch-Logs-Transformation-Configurable.md).
1. Per aggiungere un altro processore, scegli **\$1 Aggiungi processore**. Quindi seleziona il processore che desideri nella casella **Scegli processori** e inserisci i parametri di configurazione.
Ricordate che i processori operano sugli eventi di registro nell'ordine in cui li aggiungete al trasformatore.
1. (Facoltativo) In qualsiasi momento, potete testare il trasformatore che avete creato finora sulla base di un evento di registro di esempio. Per far ciò, completa le seguenti operazioni:
1. Nella sezione **Anteprima della trasformazione**, scegliete **Carica registro di esempio** per caricare un evento di registro di esempio dal gruppo di log a cui è destinato questo trasformatore, oppure incollate un evento di registro nella casella di testo.
Scegliete **Test transformer**. Viene visualizzata la versione trasformata del registro
1. Quando hai finito di aggiungere processori e sei soddisfatto dei test sui log di esempio, scegli **Salva**.
**Per utilizzarlo AWS CLI per creare un trasformatore di log partendo da zero**
+ Utilizza il comando `aws logs put-transformer`. Quando si utilizza `parseJSON` come primo processore, è necessario analizzare l'intero evento di registro utilizzandolo `@message` come campo sorgente. Dopo l'analisi JSON iniziale, è possibile manipolare campi specifici nei processori successivi. Di seguito è riportato un esempio che crea un trasformatore che include i processori and: `parseJSON` `addKeys`
```
aws logs put-transformer \
--transformer-config '[{"parseJSON":{"source":"@message"}},{"addKeys":{"entries":[{"key":"metadata.transformed_in","value":"CloudWatchLogs"},{"key":"feature","value":"Transformation"}]}},{"trimString":{"withKeys":["status"]}}]' \
--log-group-identifier my-log-group-name
```
# Crea un log-group-level trasformatore copiandone uno esistente
È possibile utilizzare la console per copiare la configurazione JSON di un trasformatore esistente. È quindi possibile utilizzare quel codice per creare un trasformatore identico utilizzando o modificare prima la configurazione. AWS CLI
**Per creare un trasformatore di log copiandone uno esistente**
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 **Log**, **Gruppi di log**.
1. Scegli il gruppo di log contenente il trasformatore che desideri copiare.
1. Scegli la **scheda Trasformazioni**. Potrebbe essere necessario scorrere l'elenco delle schede verso destra per visualizzarlo.
1. Scegli **Manage transformer**.
1. Scegli **Copy transformer**. Questo copia il trasformatore JSON negli appunti.
1. Crea un file e incollalo nella configurazione del trasformatore. In questo esempio chiameremo il file `CopiedTransformer.json`
1. Usa il AWS CLI per creare un nuovo trasformatore con quella configurazione.
```
aws logs put-transformer --log-group-identifier my-log-group-name \
--transformer-config file://CopiedTransformer.json
```
# Modifica un trasformatore log-group-level
Usa questi passaggi per modificare un trasformatore di log esistente.
**Per modificare un trasformatore 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 **Log**, **Gruppi di log**.
1. Scegli il gruppo di log contenente il trasformatore che desideri modificare.
1. Scegli la **scheda Trasformazioni**. Potrebbe essere necessario scorrere l'elenco delle schede verso destra per visualizzarlo.
1. Scegli **Manage transformer**.
1. Nelle sezioni **Parser** e **Processori**, apporta le modifiche.
1. Per aggiungere un altro processore, scegli **\$1 Aggiungi processore**. Quindi seleziona il processore che desideri nella casella **Processore** e inserisci i parametri di configurazione.
Ricordate che i processori operano sugli eventi di registro nell'ordine in cui li aggiungete al trasformatore.
1. (Facoltativo) In qualsiasi momento, potete testare il trasformatore che avete creato finora sulla base di un evento di registro di esempio. Per far ciò, completa le seguenti operazioni:
1. Nella sezione **Transformation Preview**, scegliete **Load Sample Log** per caricare un evento di log di esempio dal gruppo di log a cui è destinato questo trasformatore, oppure incollate un evento di log nella casella di testo.
Scegliete **Test Transformation**. Viene visualizzata la versione trasformata del registro
1. Quando hai finito di aggiungere processori e sei soddisfatto dei test sui log di esempio, scegli **Salva**.
# Eliminare un trasformatore log-group-level
Usa questi passaggi per eliminare un trasformatore di registro.
**Per eliminare un trasformatore 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 **Log**, **Gruppi di log**.
1. Scegli il gruppo di log contenente il trasformatore che desideri modificare.
1. Scegli la **scheda Trasformazioni**. Potrebbe essere necessario scorrere l'elenco delle schede verso destra per visualizzarlo.
1. Scegli **Elimina**.
1. Nella casella di conferma, scegli **Elimina politica**.
# Processori configurabili di tipo parser
Questa sezione contiene informazioni sui processori di analisi dei dati configurabili che è possibile utilizzare in un trasformatore di eventi di registro.
**Contents**
+ [parseJSON](#CloudWatch-Logs-Transformation-parseJSON)
+ [grok](#CloudWatch-Logs-Transformation-Grok)
+ [Esempi di Grok](#Grok-Examples)
+ [Esempio 1: Usa grok per estrarre un campo da log non strutturati](#Grok-Example1)
+ [Esempio 2: usa grok in combinazione con parseJSON per estrarre campi da un evento di registro JSON](#Grok-Example3)
+ [Esempio 3: pattern Grok con annotazione punteggiata in FIELD\$1NAME](#Grok-Example4)
+ [Schemi grok supportati](#Grok-Patterns)
+ [Esempi di formati di log comuni](#Common-Log-Examples)
+ [Esempio di log di Apache](#Apache-Log-Example)
+ [Esempio di log NGINX](#NGINX-Log-Example)
+ [Esempio di log del protocollo Syslog (RFC 5424)](#syslog5424-Log-Example)
+ [csv](#CloudWatch-Logs-Transformation-csv)
+ [parseKeyValue](#CloudWatch-Logs-Transformation-parseKeyValue)
## parseJSON
Il processore **ParseJSON** analizza gli eventi di registro JSON e inserisce le coppie chiave-valore JSON estratte nella destinazione. Se non si specifica una destinazione, il processore posiziona la coppia chiave-valore sotto il nodo radice. Quando si utilizza `parseJSON` come primo processore, è necessario analizzare l'intero evento di registro utilizzandolo `@message` come campo di origine. Dopo l'analisi JSON iniziale, è possibile manipolare campi specifici nei processori successivi.
Il `@message` contenuto originale non viene modificato, le nuove chiavi vengono aggiunte al messaggio.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| origine | Percorso del campo nel registro dell'evento che verrà analizzato. Usa la notazione a punti per accedere ai campi secondari. Ad esempio, store.book | No | `@message` | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| destinazione | Il campo di destinazione del file JSON analizzato | No | `Parent JSON node` | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
**Esempio**
Supponiamo che un evento di registro importato abbia il seguente aspetto:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
Quindi se abbiamo questo processore **ParseJson**:
```
[
{
"parseJSON": {
"destination": "new_key"
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"new_key": {
"outer_key": {
"inner_key": "inner_value"
}
}
}
```
## grok
Usa il processore grok per analizzare e strutturare i dati non strutturati utilizzando il pattern matching. Questo processore può anche estrarre campi dai messaggi di registro.
| Campo | Description | Obbligatorio? | Predefinita | Limits | Note |
| --- | --- | --- | --- | --- | --- |
| origine | Percorso del campo su cui applicare la corrispondenza Grok | No | `@message` | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| match | Il pattern grok da confrontare con l'evento log | Sì | | Lunghezza massima: 512 Schemi di gruppo massimi: 20 Alcuni tipi di pattern grok hanno limiti di utilizzo individuali. Qualsiasi combinazione dei seguenti modelli può essere utilizzata fino a cinque volte: \$1URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA\$1MULTILINE\$1 I pattern Grok non supportano le conversioni di tipo. Per i modelli di formato di log comuni (APACHE\$1ACCESS\$1LOG, NGINX\$1ACCESS\$1LOG, SYSLOG5424), è supportato l'inclusione solo dei modelli DATA, GREEDYDATA o GREEDYDATA\$1MULTILINE dopo il modello di log comune. | [Vedi tutti i pattern Grok supportati](#Grok-Patterns) |
**Struttura di un pattern Grok**
Questa è la struttura del pattern grok supportata:
```
%{PATTERN_NAME:FIELD_NAME}
```
+ **PATTERN\$1NAME**: si riferisce a un'espressione regolare predefinita per la corrispondenza di un tipo specifico di dati. [Sono supportati solo i modelli grok predefiniti.](#Grok-Patterns) La creazione di modelli personalizzati non è consentita.
+ **FIELD\$1NAME**: assegna un nome al valore estratto. `FIELD_NAME`è facoltativo, ma se non si specifica questo valore, i dati estratti verranno eliminati dall'evento di registro trasformato. Se `FIELD_NAME` utilizza la notazione punteggiata (ad esempio, «parent.child»), viene considerata un percorso JSON.
+ Conversione dei **tipi: le conversioni** di tipo esplicite non sono supportate. Usa il [TypeConverter processore](CloudWatch-Logs-Transformation-Datatype.md#CloudWatch-Logs-Transformation-typeConverter) per convertire il tipo di dati di qualsiasi valore estratto da grok.
Per creare espressioni di corrispondenza più complesse, puoi combinare diversi modelli grok. È possibile combinare fino a 20 pattern grok per abbinare un evento log. Ad esempio, questa combinazione di pattern `%{NUMBER:timestamp} [%{NUMBER:db} %{IP:client_ip}:%{NUMBER:client_port}] %{GREEDYDATA:data}` può essere utilizzata per estrarre campi da una voce di slow log di Redis come questa:
`1629860738.123456 [0 127.0.0.1:6379] "SET" "key1" "value1"`
### Esempi di Grok
#### Esempio 1: Usa grok per estrarre un campo da log non strutturati
Registro di esempio:
```
293750 server-01.internal-network.local OK "[Thread-000] token generated"
```
Trasformatore utilizzato:
```
[
{
"grok": {
"match": "%{NUMBER:version} %{HOSTNAME:hostname} %{NOTSPACE:status} %{QUOTEDSTRING:logMsg}"
}
}
]
```
Output:
```
{
"version": "293750",
"hostname": "server-01.internal-network.local",
"status": "OK",
"logMsg": "[Thread-000] token generated"
}
```
Registro di esempio:
```
23/Nov/2024:10:25:15 -0900 172.16.0.1 200
```
Trasformatore utilizzato:
```
[
{
"grok": {
"match": "%{HTTPDATE:timestamp} %{IPORHOST:clientip} %{NUMBER:response_status}"
}
}
]
```
Output:
```
{
"timestamp": "23/Nov/2024:10:25:15 -0900",
"clientip": "172.16.0.1",
"response_status": "200"
}
```
#### Esempio 2: usa grok in combinazione con parseJSON per estrarre campi da un evento di registro JSON
Registro di esempio:
```
{
"timestamp": "2024-11-23T16:03:12Z",
"level": "ERROR",
"logMsg": "GET /page.html HTTP/1.1"
}
```
Trasformatore utilizzato:
```
[
{
"parseJSON": {}
},
{
"grok": {
"source": "logMsg",
"match": "%{WORD:http_method} %{NOTSPACE:request} HTTP/%{NUMBER:http_version}"
}
}
]
```
Output:
```
{
"timestamp": "2024-11-23T16:03:12Z",
"level": "ERROR",
"logMsg": "GET /page.html HTTP/1.1",
"http_method": "GET",
"request": "/page.html",
"http_version": "1.1"
}
```
#### Esempio 3: pattern Grok con annotazione punteggiata in FIELD\$1NAME
Registro di esempio:
```
192.168.1.1 GET /index.html?param=value 200 1234
```
Trasformatore utilizzato:
```
[
{
"grok": {
"match": "%{IP:client.ip} %{WORD:method} %{URIPATHPARAM:request.uri} %{NUMBER:response.status} %{NUMBER:response.bytes}"
}
}
]
```
Output:
```
{
"client": {
"ip": "192.168.1.1"
},
"method": "GET",
"request": {
"uri": "/index.html?param=value"
},
"response": {
"status": "200",
"bytes": "1234"
}
}
```
### Schemi grok supportati
Le tabelle seguenti elencano i modelli supportati dal `grok` processore.
**Schemi di gruppo generali**
| Modello Grok | Description | Limite massimo del pattern | Esempio |
| --- | --- | --- | --- |
| USERNAME o USER | Corrisponde a uno o più caratteri che possono includere lettere minuscole (a-z), lettere maiuscole (A-Z), cifre (0-9), punti (.), caratteri di sottolineatura (\$1) o trattini (-) | 20 | Input: `user123.name-TEST` Modello: `%{USERNAME:name}` Uscita: `{"name": "user123.name-TEST"}` |
| INT | Corrisponde a un segno più o meno opzionale seguito da una o più cifre. | 20 | Ingresso: `-456` Modello: `%{INT:num}` Uscita: `{"num": "-456"}` |
| BASE10NUM | Corrisponde a un numero intero o a virgola mobile con segno e virgola decimale opzionali | 20 | Ingresso: `-0.67` Modello: `%{BASE10NUM:num}` Uscita: `{"num": "-0.67"}` |
| BASE16NUM | Corrisponde ai numeri decimali ed esadecimali con un segno opzionale (\$1 o -) e un prefisso 0x opzionale | 20 | Ingresso: `+0xA1B2` Modello: `%{BASE16NUM:num}` Uscita: `{"num": "+0xA1B2"}` |
| PUNTO | Corrisponde a numeri interi positivi senza zeri iniziali, costituiti da una o più cifre (1-9 seguito da 0-9) | 20 | Ingresso: `123` Modello: `%{POSINT:num}` Uscita: `{"num": "123"}` |
| NONNEGINT | Corrisponde a qualsiasi numero intero (composto da una o più cifre da 0 a 9) compresi zero e numeri con zeri iniziali. | 20 | Ingresso: `007` Modello: `%{NONNEGINT:num}` Uscita: `{"num": "007"}` |
| PAROLA | Corrisponde a parole intere composte da uno o più caratteri di parola (\$1 w), incluse lettere, cifre e caratteri di sottolineatura | 20 | Ingresso: `user_123` Modello: `%{WORD:user}` Uscita: `{"user": "user_123"}` |
| NON SPAZIO | Corrisponde a uno o più caratteri diversi dagli spazi bianchi. | 5 | Ingresso: `hello_world123` Modello: `%{NOTSPACE:msg}` Uscita: `{"msg": "hello_world123"}` |
| SPACE | Corrisponde a zero o più caratteri di spazio bianco. | 5 | Ingresso: `" "` Modello: `%{SPACE:extra}` Uscita: `{"extra": " "}` |
| DATA | Corrisponde a qualsiasi carattere (eccetto la nuova riga) zero o più volte, non è avido. | 5 | Ingresso: `abc def ghi` Modello: `%{DATA:x} %{DATA:y}` Uscita: `{"x": "abc", "y": "def ghi"}` |
| DATI AVIDI | Corrisponde a qualsiasi carattere (eccetto la nuova riga) zero o più volte, greedy. | 5 | Ingresso: `abc def ghi` Modello: `%{GREEDYDATA:x} %{GREEDYDATA:y}` Uscita: `{"x": "abc def", "y": "ghi"}` |
| GREEDYDATA\$1MULTILINE | Corrisponde a qualsiasi carattere (inclusa la nuova riga) zero o più volte, greedy. | 1 | Input: `abc` `def` `ghi` Modello: `%{GREEDYDATA_MULTILINE:data}` Uscita: `{"data": "abc\ndef\nghi"}` |
| STRINGA TRA VIRGOLETTE | Corrisponde alle stringhe tra virgolette (virgolette singole o doppie) ai caratteri con escape. | 20 | Ingresso: `"Hello, world!"` Modello: `%{QUOTEDSTRING:msg}` Uscita: `{"msg": "Hello, world!"}` |
| UUID | Corrisponde a un formato UUID standard: 8 caratteri esadecimali, seguiti da tre gruppi di 4 caratteri esadecimali e termina con 12 caratteri esadecimali, tutti separati da trattini. | 20 | Ingresso: `550e8400-e29b-41d4-a716-446655440000` Modello: `%{UUID:id}` Uscita: `{"id": "550e8400-e29b-41d4-a716-446655440000"}` |
| URNA | Corrisponde alla sintassi URN (Uniform Resource Name). | 20 | Ingresso: `urn:isbn:0451450523` Modello: `%{URN:urn}` Uscita: `{"urn": "urn:isbn:0451450523"}` |
**AWS modelli grok**
| Pattern | Description | Limite massimo del modello | Esempio |
| --- | --- | --- | --- |
| ARN | Corrisponde AWS ad Amazon Resource Names (ARNs), acquisendo la partizione (`aws`,, or`aws-us-gov`)`aws-cn`, il servizio, la regione, l'ID account e fino a 5 identificatori gerarchici di risorse separati da barre. Non ARNs corrisponderà alle informazioni mancanti tra i due punti. | 5 | Ingresso: `arn:aws:iam:us-east-1:123456789012:user/johndoe` Modello: `%{ARN:arn}` Uscita: `{"arn": "arn:aws:iam:us-east-1:123456789012:user/johndoe"}` |
**Schemi di gruppo di rete**
| Modello Grok | Description | Limite massimo del pattern | Esempio |
| --- | --- | --- | --- |
| CISCOMAC | Corrisponde a un indirizzo MAC in formato esadecimale 4-4-4. | 20 | Ingresso: `0123.4567.89AB` Modello: `%{CISCOMAC:MacAddress}` Uscita: `{"MacAddress": "0123.4567.89AB"}` |
| WINDOWS MAC | Corrisponde a un indirizzo MAC in formato esadecimale con trattini | 20 | Ingresso: `01-23-45-67-89-AB` Modello: `%{WINDOWSMAC:MacAddress}` Uscita: `{"MacAddress": "01-23-45-67-89-AB"}` |
| MAC COMUNE | Corrisponde a un indirizzo MAC in formato esadecimale con due punti. | 20 | Ingresso: `01:23:45:67:89:AB` Modello: `%{COMMONMAC:MacAddress}` Uscita: `{"MacAddress": "01:23:45:67:89:AB"}` |
| MAC | Corrisponde a uno dei pattern grok CISCOMAC, WINDOWSMAC o COMMONMAC | 20 | Ingresso: `01:23:45:67:89:AB` Modello: `%{MAC:m1}` Uscita: `{"m1":"01:23:45:67:89:AB"}` |
| IPV6 | Corrisponde IPv6 agli indirizzi, inclusi i moduli compressi e gli indirizzi IPv4 mappati IPv6 . | 5 | Ingresso: `2001:db8:3333:4444:5555:6666:7777:8888` Modello: `%{IPV6:ip}` Uscita: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| IPV4 | Corrisponde a un IPv4 indirizzo. | 20 | Ingresso: `192.168.0.1` Modello: `%{IPV4:ip}` Uscita: `{"ip": "192.168.0.1"}` |
| IP | IPv6 Corrisponde agli indirizzi supportati da% \$1IPv6\$1 o IPv4 agli indirizzi supportati da% \$1IPv4\$1 | 5 | Ingresso: `192.168.0.1` Modello: `%{IP:ip}` Uscita: `{"ip": "192.168.0.1"}` |
| HOSTNAME o HOST | Corrisponde ai nomi di dominio, inclusi i sottodomini | 5 | Ingresso: `server-01.internal-network.local` Modello: `%{HOST:host}` Uscita: `{"host": "server-01.internal-network.local"}` |
| IP O HOST | Corrisponde a un nome host o a un indirizzo IP | 5 | Ingresso: `2001:db8:3333:4444:5555:6666:7777:8888` Modello: `%{IPORHOST:ip}` Uscita: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| HOSTPORT | Corrisponde a un indirizzo IP o a un nome host come supportato dal pattern% \$1IPORHOST\$1 seguito da due punti e da un numero di porta, che nell'output registra la porta come «PORT». | 5 | Ingresso: `192.168.1.1:8080` Modello: `%{HOSTPORT:ip}` Uscita: `{"ip":"192.168.1.1:8080","PORT":"8080"}` |
| URIHOST | Corrisponde a un indirizzo IP o a un nome host, come supportato dal pattern% \$1IPORHOST\$1, seguito facoltativamente da due punti e da un numero di porta, identificando la porta come «porta», se presente. | 5 | Ingresso: `example.com:443 10.0.0.1` Modello: `%{URIHOST:host} %{URIHOST:ip}` Uscita: `{"host":"example.com:443","port":"443","ip":"10.0.0.1"}` |
**Schemi di gruppi di tracciati**
| Modello Grok | Description | Limite massimo del pattern | Esempio |
| --- | --- | --- | --- |
| UNIXPATH | Corrisponde ai percorsi degli URL, inclusi potenzialmente i parametri di query. | 20 | Ingresso: `/search?q=regex` Modello: `%{UNIXPATH:path}` Uscita: `{"path":"/search?q=regex"}` |
| PERCORSO VINCENTE | Corrisponde ai percorsi dei file di Windows. | 5 | Ingresso: `C:\Users\John\Documents\file.txt` Modello: `%{WINPATH:path}` Uscita: `{"path": "C:\\Users\\John\\Documents\\file.txt"}` |
| PATH | Corrisponde ai percorsi dei file URL o Windows | 5 | Ingresso: `/search?q=regex` Modello: `%{PATH:path}` Uscita: `{"path":"/search?q=regex"}` |
| TTY | Corrisponde ai percorsi dei dispositivi Unix per terminali e pseudo-terminali. | 20 | Ingresso: `/dev/tty1` Modello: `%{TTY:path}` Uscita: `{"path":"/dev/tty1"}` |
| URIPROTO | Corrisponde alle lettere, seguite facoltativamente da un carattere più (\$1) e lettere aggiuntive o caratteri più (\$1) | 20 | Ingresso: `web+transformer` Modello: `%{URIPROTO:protocol}` Uscita: `{"protocol":"web+transformer"}` |
| URIPATA | Corrisponde al componente del percorso di un URI | 20 | Ingresso: `/category/sub-category/product_name` Modello: `%{URIPATH:path}` Uscita: `{"path":"/category/sub-category/product_name"}` |
| URIPARAM | Corrisponde ai parametri della query URL | 5 | Ingresso: `?param1=value1¶m2=value2` Modello: `%{URIPARAM:url}` Uscita: `{"url":"?param1=value1¶m2=value2"}` |
| PARAMETRO URIPATH | Corrisponde a un percorso URI seguito facoltativamente da parametri di query | 5 | Ingresso: `/category/sub-category/product?id=12345&color=red` Modello: `%{URIPATHPARAM:path}` Uscita: `{"path":"/category/sub-category/product?id=12345&color=red"}` |
| URI | Corrisponde a un URI completo | 5 | Ingresso: `https://user:password@example.com/path/to/resource?param1=value1¶m2=value2` Modello: `%{URI:uri}` Uscita: `{"path":"https://user:password@example.com/path/to/resource?param1=value1¶m2=value2"}` |
**Schemi grok di data e ora**
| Modello Grok | Description | Limite massimo del pattern | Esempio |
| --- | --- | --- | --- |
| MESE | Corrisponde ai nomi completi o abbreviati dei mesi inglesi a parole intere | 20 | Ingresso: `Jan` Modello: `%{MONTH:month}` Uscita: `{"month":"Jan"}` Ingresso: `January` Modello: `%{MONTH:month}` Uscita: `{"month":"January"}` |
| NUMERO DI MESI | Corrisponde ai numeri dei mesi da 1 a 12, con lo zero iniziale opzionale per i mesi a una cifra. | 20 | Ingresso: `5` Modello: `%{MONTHNUM:month}` Uscita: `{"month":"5"}` Ingresso: `05` Modello: `%{MONTHNUM:month}` Uscita: `{"month":"05"}` |
| MONTHNUM2 | Corrisponde ai numeri dei mesi a due cifre compresi tra 01 e 12. | 20 | Ingresso: `05` Modello: `%{MONTHNUM2:month}` Uscita: `{"month":"05"}` |
| MESE/GIORNO | Corrisponde al giorno del mese compreso tra 1 e 31, con zero iniziale opzionale. | 20 | Ingresso: `31` Modello: `%{MONTHDAY:monthDay}` Uscita: `{"monthDay":"31"}` |
| ANNO | Corrisponde all'anno in due o quattro cifre | 20 | Ingresso: `2024` Modello: `%{YEAR:year}` Uscita: `{"year":"2024"}` Ingresso: `24` Modello: `%{YEAR:year}` Uscita: `{"year":"24"}` |
| GIORNO | Corrisponde ai nomi dei giorni completi o abbreviati. | 20 | Ingresso: `Tuesday` Modello: `%{DAY:day}` Uscita: `{"day":"Tuesday"}` |
| ORA | Corrisponde all'ora nel formato a 24 ore con uno zero iniziale opzionale (0) 0-23. | 20 | Ingresso: `22` Modello: `%{HOUR:hour}` Uscita: `{"hour":"22"}` |
| MINUTO | Corrisponde ai minuti (00-59). | 20 | Ingresso: `59` Modello: `%{MINUTE:min}` Uscita: `{"min":"59"}` |
| SECOND | Corrisponde a un numero che rappresenta i secondi (0) 0-60, seguito facoltativamente da un punto decimale o due punti e da una o più cifre per i minuti frazionari | 20 | Ingresso: `3` Modello: `%{SECOND:second}` Uscita: `{"second":"3"}` Ingresso: `30.5` Modello: `%{SECOND:minSec}` Uscita: `{"minSec":"30.5"}` Ingresso: `30:5` Modello: `%{SECOND:minSec}` Uscita: `{"minSec":"30:5"}` |
| TIME | Corrisponde a un formato orario con ore, minuti e secondi nel formato (H) H:mm :( s) s. I secondi includono il secondo intercalare (0) 0-60. | 20 | Ingresso: `09:45:32` Modello: `%{TIME:time}` Uscita: `{"time":"09:45:32"}` |
| DATA\$1US | Corrisponde a una data nel formato (M) M/ (d) d/ (yy) yy o (M) M- (d) d- (yy) yy. | 20 | Ingresso: `11/23/2024` Modello: `%{DATE_US:date}` Uscita: `{"date":"11/23/2024"}` Ingresso: `1-01-24` Modello: `%{DATE_US:date}` Uscita: `{"date":"1-01-24"}` |
| DATE\$1EU | Corrisponde alla data nel formato (d) d/ (M) M/ (yy) yy, (d) d- (M) M- (yy) yy o (d) d. (M) M. (yy) yy. | 20 | Ingresso: `23/11/2024` Modello: `%{DATE_EU:date}` Uscita: `{"date":"23/11/2024"}` Ingresso: `1.01.24` Modello: `%{DATE_EU:date}` Uscita: `{"date":"1.01.24"}` |
| ISO8601\$1FUSO ORARIO | Corrisponde all'offset UTC 'Z' o all'offset del fuso orario con due punti opzionali nel formato [\$1-] (H) H (:) mm. | 20 | Ingresso: `+05:30` Modello: `%{ISO8601_TIMEZONE:tz}` Uscita: `{"tz":"+05:30"}` Ingresso: `-530` Modello: `%{ISO8601_TIMEZONE:tz}` Uscita: `{"tz":"-530"}` Ingresso: `Z` Modello: `%{ISO8601_TIMEZONE:tz}` Uscita: `{"tz":"Z"}` |
| ISO8601\$1SECONDO | Corrisponde a un numero che rappresenta i secondi (0) 0-60, seguito facoltativamente da un punto decimale o due punti e da una o più cifre per frazioni di secondo | 20 | Ingresso: `60` Modello: `%{ISO8601_SECOND:second}` Uscita: `{"second":"60"}` |
| TIMESTAMP\$1 ISO8601 | Corrisponde al formato ISO8601 datetime (yy) yy- (M) M- (d) dT (H) H:mm :( (s) s) (Z\$1 [\$1-] (H) H:mm) con secondi e fuso orario opzionali. | 20 | Ingresso: `2023-05-15T14:30:00+05:30` Modello: `%{TIMESTAMP_ISO8601:timestamp}` Uscita: `{"timestamp":"2023-05-15T14:30:00+05:30"}` Ingresso: `23-5-1T1:25+5:30` Modello: `%{TIMESTAMP_ISO8601:timestamp}` Uscita: `{"timestamp":"23-5-1T1:25+5:30"}` Ingresso: `23-5-1T1:25Z` Modello: `%{TIMESTAMP_ISO8601:timestamp}` Uscita: `{"timestamp":"23-5-1T1:25Z"}` |
| DATE | Corrisponde a una data nel formato USA utilizzando% \$1DATE\$1US\$1 o nel formato UE utilizzando% \$1DATE\$1EU\$1 | 20 | Ingresso: `11/29/2024` Modello: `%{DATE:date}` Uscita: `{"date":"11/29/2024"}` Ingresso: `29.11.2024` Modello: `%{DATE:date}` Uscita: `{"date":"29.11.2024"}` |
| TIMBRO DATARIO | Corrisponde a% \$1DATE\$1 seguito dallo schema% \$1TIME\$1, separato da uno spazio o da un trattino. | 20 | Ingresso: `29-11-2024 14:30:00` Modello: `%{DATESTAMP:dateTime}` Uscita: `{"dateTime":"29-11-2024 14:30:00"}` |
| TZ | Corrisponde alle abbreviazioni dei fusi orari comuni (PST, PDT, MST, MDT, CST CDT, EST, EDT, UTC). | 20 | Ingresso: `PDT` Modello: `%{TZ:tz}` Uscita: `{"tz":"PDT"}` |
| DATESTAMP\$1 RFC822 | Corrisponde a data e ora nel formato: Day MonthName (D) D (YY) YY (H) H:mm :( s) s Timezone | 20 | Ingresso: `Monday Jan 5 23 1:30:00 CDT` Modello: `%{DATESTAMP_RFC822:dateTime}` Uscita: `{"dateTime":"Monday Jan 5 23 1:30:00 CDT"}` Ingresso: `Mon January 15 2023 14:30:00 PST` Modello: `%{DATESTAMP_RFC822:dateTime}` Uscita: `{"dateTime":"Mon January 15 2023 14:30:00 PST"}` |
| DATESTAMP\$1 RFC2822 | Corrisponde al formato RFC2822 data-ora: Day, (d) d (yy) yy MonthName (H) H:mm :( s) s Z\$1 [\$1-] (H) H:mm | 20 | Ingresso: `Mon, 15 May 2023 14:30:00 +0530` Modello: `%{DATESTAMP_RFC2822:dateTime}` Uscita: `{"dateTime":"Mon, 15 May 2023 14:30:00 +0530"}` Ingresso: `Monday, 15 Jan 23 14:30:00 Z` Modello: `%{DATESTAMP_RFC2822:dateTime}` Uscita: `{"dateTime":"Monday, 15 Jan 23 14:30:00 Z"}` |
| DATESTAMP\$1OTHER | Corrisponde a data e ora nel formato: Giorno MonthName (d) d (H) H:mm :( s) s Fuso orario (yy) yy | 20 | Ingresso: `Mon May 15 14:30:00 PST 2023` Modello: `%{DATESTAMP_OTHER:dateTime}` Uscita: `{"dateTime":"Mon May 15 14:30:00 PST 2023"}` |
| DATESTAMP\$1EVENTLOG | Corrisponde al formato datetime compatto senza separatori: (yy) yYmm (d) d (H) Hmm (s) s | 20 | Ingresso: `20230515143000` Modello: `%{DATESTAMP_EVENTLOG:dateTime}` Uscita: `{"dateTime":"20230515143000"}` |
**Schemi di gruppo logaritmici**
| Modello Grok | Description | Limite massimo del pattern | Esempio |
| --- | --- | --- | --- |
| LIVELLO DI REGISTRO | Corrisponde ai livelli di log standard in diverse lettere maiuscole e abbreviazioni, tra cui:Alert/ALERT,Trace/TRACE,Debug/DEBUG,Notice/NOTICE,Info/INFO,,Warn/Warning/WARN/WARNING,Err/Error/ERR/ERROR, Crit/Critical/CRIT/CRITICAL Fatal/FATAL Severe/SEVERE Emerg/Emergency/EMERG/EMERGENCY | 20 | Ingresso: `INFO` Modello: `%{LOGLEVEL:logLevel}` Uscita: `{"logLevel":"INFO"}` |
| HTTP: DATA | Corrisponde al formato di data e ora spesso utilizzato nei file di registro. Formato: (d) d/MonthName/(yy) yy :( H) H:mm :( s) s Fuso orario: corrisponde ai nomi completi o abbreviati dei mesi in inglese (esempio MonthName: «Jan» o «January») Fuso orario: corrisponde al modello% \$1INT\$1 grok | 20 | Ingresso: `23/Nov/2024:14:30:00 +0640` Modello: `%{HTTPDATE:date}` Uscita: `{"date":"23/Nov/2024:14:30:00 +0640"}` |
| TIMESTAMP SYSLOG | Corrisponde al formato della data con MonthName (d) d (H) H:mm :( s) s: corrisponde ai nomi completi o abbreviati dei mesi in inglese (esempio MonthName: «Jan» o «January») | 20 | Ingresso: `Nov 29 14:30:00` Modello: `%{SYSLOGTIMESTAMP:dateTime}` Uscita: `{"dateTime":"Nov 29 14:30:00"}` |
| PROG | Corrisponde al nome di un programma composto da una stringa di lettere, cifre, punti, trattini bassi, barra, segno di percentuale e trattini. | 20 | Ingresso: `user.profile/settings-page` Modello: `%{PROG:program}` Uscita: `{"program":"user.profile/settings-page"}` |
| SYSLOGPROG | Corrisponde al pattern PROG grok seguito facoltativamente da un ID di processo tra parentesi quadre. | 20 | Ingresso: `user.profile/settings-page[1234]` Modello: `%{SYSLOGPROG:programWithId}` Uscita: `{"programWithId":"user.profile/settings-page[1234]","program":"user.profile/settings-page","pid":"1234"}` |
| SYSLOGHOST | Corrisponde a uno schema% \$1HOST\$1 o% \$1IP\$1 | 5 | Ingresso: `2001:db8:3333:4444:5555:6666:7777:8888` Modello: `%{SYSLOGHOST:ip}` Uscita: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| IMPIANTO SYSLOG | Corrisponde alla priorità syslog in formato decimale. Il valore deve essere racchiuso tra parentesi angolari (<>). | 20 | Ingresso: `<13.6>` Modello: `%{SYSLOGFACILITY:syslog}` Uscita: `{"syslog":"<13.6>","facility":"13","priority":"6"}` |
**Schemi di log grok comuni**
È possibile utilizzare modelli grok personalizzati predefiniti per abbinare i formati di registro Apache, NGINX e Syslog Protocol (RFC 5424). Quando si utilizzano questi modelli specifici, devono essere i primi modelli nella configurazione corrispondente e nessun altro modello può precederli. Inoltre, puoi seguirli solo con esattamente un **DATO**. **Pattern GREEDYDATA o GREEDYDATA\$1MULTILINE****.**
| Pattern grok | Description | Limite massimo del modello |
| --- | --- | --- |
| APACHE\$1ACCESS\$1LOG | Corrisponde ai log di accesso di Apache | 1 |
| NGINX\$1ACCESS\$1LOG | Corrisponde ai log di accesso NGINX | 1 |
| SYSLOG5424 | Corrisponde ai log del protocollo Syslog (RFC 5424) | 1 |
Di seguito sono riportati esempi validi e non validi per l'utilizzo di questi modelli di formato di registro comuni.
```
"%{NGINX_ACCESS_LOG} %{DATA}" // Valid
"%{SYSLOG5424}%{DATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{GREEDYDATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{SYSLOG5424}" // Invalid (multiple common log patterns used)
"%{NGINX_ACCESS_LOG} %{NUMBER:num}" // Invalid (Only GREEDYDATA and DATA patterns are supported with common log patterns)
"%{GREEDYDATA:logMsg} %{SYSLOG5424}" // Invalid (GREEDYDATA and DATA patterns are supported only after common log patterns)
```
#### Esempi di formati di log comuni
##### Esempio di log di Apache
Registro di esempio:
```
127.0.0.1 - - [03/Aug/2023:12:34:56 +0000] "GET /page.html HTTP/1.1" 200 1234
```
Trasformatore:
```
[
{
"grok": {
"match": "%{APACHE_ACCESS_LOG}"
}
}
]
```
Output:
```
{
"request": "/page.html",
"http_method": "GET",
"status_code": 200,
"http_version": "1.1",
"response_size": 1234,
"remote_host": "127.0.0.1",
"timestamp": "2023-08-03T12:34:56Z"
}
```
##### Esempio di log NGINX
Registro di esempio:
```
192.168.1.100 - Foo [03/Aug/2023:12:34:56 +0000] "GET /account/login.html HTTP/1.1" 200 42 "https://www.amazon.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36"
```
Trasformatore:
```
[
{
"grok": {
"match": "%{NGINX_ACCESS_LOG}"
}
}
]
```
Output:
```
{
"request": "/account/login.html",
"referrer": "https://www.amazon.com/",
"agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36",
"http_method": "GET",
"status_code": 200,
"auth_user": "Foo",
"http_version": "1.1",
"response_size": 42,
"remote_host": "192.168.1.100",
"timestamp": "2023-08-03T12:34:56Z"
}
```
##### Esempio di log del protocollo Syslog (RFC 5424)
Registro di esempio:
```
<165>1 2003-10-11T22:14:15.003Z mymachine.example.com evntslog - ID47 [exampleSDID@32473 iut="3" eventSource= "Application" eventID="1011"][examplePriority@32473 class="high"]
```
Trasformatore:
```
[
{
"grok": {
"match": "%{SYSLOG5424}"
}
}
]
```
Output:
```
{
"pri": 165,
"version": 1,
"timestamp": "2003-10-11T22:14:15.003Z",
"hostname": "mymachine.example.com",
"app": "evntslog",
"msg_id": "ID47",
"structured_data": "exampleSDID@32473 iut=\"3\" eventSource= \"Application\" eventID=\"1011\"",
"message": "[examplePriority@32473 class=\"high\"]"
}
```
## csv
Il processore **csv** analizza i valori separati da virgole (CSV) dagli eventi di registro in colonne.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| origine | Percorso del campo nell'evento di registro che verrà analizzato | No | `@message` | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| delimitatore | Il carattere utilizzato per separare ogni colonna nell'evento di registro dei valori separati da virgole originale | No | `,` | Lunghezza massima: 1 a meno che il valore non sia o `\t` `\s` |
| Cita carattere | Carattere utilizzato come qualificatore di testo per una singola colonna di dati | No | `"` | Lunghezza massima: 1 |
| columns | Elenco di nomi da utilizzare per le colonne dell'evento di registro trasformato. | No | `[column_1, column_2 ...]` | Numero massimo di colonne CSV: 100 Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| destinazione | Il campo principale in cui inserire le coppie chiave-valore trasformate | No | `Root node` | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
L'impostazione `delimiter` su `\t` separerà ogni colonna su un carattere di tabulazione e `\t` separerà ogni colonna su un singolo carattere di spazio.
**Esempio**
Supponiamo che parte di un evento di registro importato abbia il seguente aspetto:
```
'Akua Mansa':28:'New York: USA'
```
**Supponiamo di utilizzare solo il processore csv:**
```
[
{
"csv": {
"delimiter": ":",
"quoteCharacter": "'"
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"column_1": "Akua Mansa",
"column_2": "28",
"column_3": "New York: USA"
}
```
**Esempio 2**
Supponiamo che un evento di registro importato abbia il seguente aspetto:
```
{
"timestamp": "2024-11-23T16:03:12Z",
"type": "user_data",
"logMsg": "'Akua Mansa':28:'New York: USA'"
}
```
Supponiamo di analizzare l'evento come JSON, loro analizzano un campo JSON con il processore **csv**, specificando i nomi delle colonne e la destinazione:
```
[
{
"parseJSON": {}
},
{
"csv": {
"source": "logMsg",
"delimiter": ":",
"quoteCharacter": "'",
"columns":["name","age","location"],
"destination": "msg"
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"timestamp": "2024-11-23T16:03:12Z",
"logMsg": "'Akua Mansa':28:'New York: USA'",
"type": "user_data",
"msg": {
"name": "Akua Mansa",
"age": "28",
"location": "New York: USA"
}
}
```
## parseKeyValue
Utilizzate il **parseKeyValue**processore per analizzare un campo specificato in coppie chiave-valore. È possibile personalizzare il processore per analizzare le informazioni sui campi con le seguenti opzioni.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| origine | Percorso del campo nel registro dell'evento che verrà analizzato | No | `@message` | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| destinazione | Il campo di destinazione in cui inserire le coppie chiave-valore estratte | No | | Lunghezza massima: 128. |
| FieldDelimiter | La stringa delimitatrice di campo utilizzata tra coppie chiave-valore negli eventi del registro originale | No | `&` | Lunghezza massima: 128. |
| keyValueDelimiter | La stringa delimitatrice da utilizzare tra la chiave e il valore in ogni coppia nell'evento di registro trasformato | No | `=` | Lunghezza massima: 128. |
| nonMatchValue | Un valore da inserire nel campo del valore del risultato, quando una coppia chiave-valore non viene divisa correttamente. | No | | Lunghezza massima: 128. |
| keyPrefix | Se vuoi aggiungere un prefisso a tutte le chiavi trasformate, specificalo qui. | No | | Lunghezza massima: 128. |
| overwriteIfExists | Se sovrascrivere il valore se la chiave di destinazione esiste già | No | `false` | |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
key1:value1!key2:value2!key3:value3!key4
```
Supponiamo di utilizzare la seguente configurazione del processore:
```
[
{
"parseKeyValue": {
"destination": "new_key",
"fieldDelimiter": "!",
"keyValueDelimiter": ":",
"nonMatchValue": "defaultValue",
"keyPrefix": "parsed_"
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"new_key": {
"parsed_key1": "value1",
"parsed_key2": "value2",
"parsed_key3": "value3",
"parsed_key4": "defaultValue"
}
}
```
# Processori integrati per i AWS log venduti
Questa sezione contiene informazioni sui processori integrati che è possibile utilizzare con AWS i servizi che vendono log.
**Contents**
+ [ParseWAF](#CloudWatch-Logs-Transformation-parseWAF)
+ [parsePostGres](#CloudWatch-Logs-Transformation-parsePostGres)
+ [parseCloudFront](#CloudWatch-Logs-Transformation-parseCloudFront)
+ [parseRoute53](#CloudWatch-Logs-Transformation-parseRoute53)
+ [ParseVPC](#CloudWatch-Logs-Transformation-parseVPC)
+ [parseToOCSF](CloudWatch-Logs-Transformation-parseToOCSF.md)
## ParseWAF
Usa questo processore per analizzare i log AWS WAF venduti, prende il contenuto `httpRequest.headers` e crea chiavi JSON da ogni nome di intestazione, con il valore corrispondente. Fa lo stesso anche per. `labels` Queste trasformazioni possono rendere molto più semplice l'interrogazione dei AWS WAF log. Per ulteriori informazioni sul formato dei AWS WAF log, consulta [Esempi di log per il traffico ACL web](https://docs.aws.amazon.com/waf/latest/developerguide/logging-examples.html).
Questo processore accetta solo `@message` come input.
**Importante**
Se si utilizza questo processore, deve essere il primo processore del trasformatore.
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"timestamp": 1576280412771,
"formatVersion": 1,
"webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
"terminatingRuleId": "STMTest_SQLi_XSS",
"terminatingRuleType": "REGULAR",
"action": "BLOCK",
"terminatingRuleMatchDetails": [
{
"conditionType": "SQL_INJECTION",
"sensitivityLevel": "HIGH",
"location": "HEADER",
"matchedData": ["10", "AND", "1"]
}
],
"httpSourceName": "-",
"httpSourceId": "-",
"ruleGroupList": [],
"rateBasedRuleList": [],
"nonTerminatingMatchingRules": [],
"httpRequest": {
"clientIp": "1.1.1.1",
"country": "AU",
"headers": [
{ "name": "Host", "value": "localhost:1989" },
{ "name": "User-Agent", "value": "curl/7.61.1" },
{ "name": "Accept", "value": "*/*" },
{ "name": "x-stm-test", "value": "10 AND 1=1" }
],
"uri": "/myUri",
"args": "",
"httpVersion": "HTTP/1.1",
"httpMethod": "GET",
"requestId": "rid"
},
"labels": [{ "name": "value" }]
}
```
La configurazione del processore è la seguente:
```
[
{
"parseWAF": {}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"httpRequest": {
"headers": {
"Host": "localhost:1989",
"User-Agent": "curl/7.61.1",
"Accept": "*/*",
"x-stm-test": "10 AND 1=1"
},
"clientIp": "1.1.1.1",
"country": "AU",
"uri": "/myUri",
"args": "",
"httpVersion": "HTTP/1.1",
"httpMethod": "GET",
"requestId": "rid"
},
"labels": { "name": "value" },
"timestamp": 1576280412771,
"formatVersion": 1,
"webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
"terminatingRuleId": "STMTest_SQLi_XSS",
"terminatingRuleType": "REGULAR",
"action": "BLOCK",
"terminatingRuleMatchDetails": [
{
"conditionType": "SQL_INJECTION",
"sensitivityLevel": "HIGH",
"location": "HEADER",
"matchedData": ["10", "AND", "1"]
}
],
"httpSourceName": "-",
"httpSourceId": "-",
"ruleGroupList": [],
"rateBasedRuleList": [],
"nonTerminatingMatchingRules": []
}
```
## parsePostGres
Usa questo processore per analizzare i log Amazon RDS for PostgreSQL forniti, estrarre campi e convertirli in formato JSON. Per ulteriori informazioni sul formato di registro RDS for PostgreSQL, consulta File di log del database [RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.Concepts.PostgreSQL.html#USER_LogAccess.Concepts.PostgreSQL.Log_Format.log-line-prefix) for PostgreSQL.
Questo processore accetta solo come input. `@message`
**Importante**
Se si utilizza questo processore, deve essere il primo processore del trasformatore.
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
2019-03-10 03:54:59 UTC:10.0.0.123(52834):postgres@logtestdb:[20175]:ERROR: column "wrong_column_name" does not exist at character 8
```
La configurazione del processore è la seguente:
```
[
{
"parsePostgres": {}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"logTime": "2019-03-10 03:54:59 UTC",
"srcIp": "10.0.0.123(52834)",
"userName": "postgres",
"dbName": "logtestdb",
"processId": "20175",
"logLevel": "ERROR"
}
```
## parseCloudFront
Usa questo processore per analizzare i log Amazon CloudFront forniti, estrarre campi e convertirli in formato JSON. I valori dei campi codificati vengono decodificati. I valori interi e doppi vengono trattati come tali. Per ulteriori informazioni sul formato dei Amazon CloudFront log, consulta [Configurare e utilizzare i log standard (log di accesso).](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html)
Questo processore accetta solo `@message` come input.
**Importante**
Se si utilizza questo processore, deve essere il primo processore del trasformatore.
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
2019-12-04 21:02:31 LAX1 392 192.0.2.24 GET d111111abcdef8.cloudfront.net /index.html 200 - Mozilla/5.0%20(Windows%20NT%2010.0;%20Win64;%20x64)%20AppleWebKit/537.36%20(KHTML,%20like%20Gecko)%20Chrome/78.0.3904.108%20Safari/537.36 - - Hit SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ== d111111abcdef8.cloudfront.net https 23 0.001 - TLSv1.2 ECDHE-RSA-AES128-GCM-SHA256 Hit HTTP/2.0 - - 11040 0.001 Hit text/html 78 - -
```
La configurazione del processore è la seguente:
```
[
{
"parseCloudfront": {}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"date": "2019-12-04",
"time": "21:02:31",
"x-edge-location": "LAX1",
"sc-bytes": 392,
"c-ip": "192.0.2.24",
"cs-method": "GET",
"cs(Host)": "d111111abcdef8.cloudfront.net",
"cs-uri-stem": "/index.html",
"sc-status": 200,
"cs(Referer)": "-",
"cs(User-Agent)": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36",
"cs-uri-query": "-",
"cs(Cookie)": "-",
"x-edge-result-type": "Hit",
"x-edge-request-id": "SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ==",
"x-host-header": "d111111abcdef8.cloudfront.net",
"cs-protocol": "https",
"cs-bytes": 23,
"time-taken": 0.001,
"x-forwarded-for": "-",
"ssl-protocol": "TLSv1.2",
"ssl-cipher": "ECDHE-RSA-AES128-GCM-SHA256",
"x-edge-response-result-type": "Hit",
"cs-protocol-version": "HTTP/2.0",
"fle-status": "-",
"fle-encrypted-fields": "-",
"c-port": 11040,
"time-to-first-byte": 0.001,
"x-edge-detailed-result-type": "Hit",
"sc-content-type": "text/html",
"sc-content-len": 78,
"sc-range-start": "-",
"sc-range-end": "-"
}
```
## parseRoute53
Usa questo processore per analizzare i log Amazon Route 53 Public Data Plane forniti, estrarre campi e convertirli in formato JSON. I valori dei campi codificati vengono decodificati. Questo processore non supporta Amazon Route 53 Resolver i log.
Questo processore accetta solo `@message` come input.
**Importante**
Se si utilizza questo processore, deve essere il primo processore del trasformatore.
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
1.0 2017-12-13T08:15:50.235Z Z123412341234 example.com AAAA NOERROR TCP IAD12 192.0.2.0 198.51.100.0/24
```
La configurazione del processore è la seguente:
```
[
{
"parseRoute53": {}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"version": 1.0,
"queryTimestamp": "2017-12-13T08:15:50.235Z",
"hostZoneId": "Z123412341234",
"queryName": "example.com",
"queryType": "AAAA",
"responseCode": "NOERROR",
"protocol": "TCP",
"edgeLocation": "IAD12",
"resolverIp": "192.0.2.0",
"ednsClientSubnet": "198.51.100.0/24"
}
```
## ParseVPC
Usa questo processore per analizzare i log venduti da Amazon VPC, estrarre campi e convertirli in formato JSON. I valori dei campi codificati vengono decodificati.
Questo processore accetta solo `@message` come input.
**Importante**
Se si utilizza questo processore, deve essere il primo processore del trasformatore.
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
2 123456789010 eni-abc123de 192.0.2.0 192.0.2.24 20641 22 6 20 4249 1418530010 1418530070 ACCEPT OK
```
La configurazione del processore è la seguente:
```
[
{
"parseVPC": {}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"version": 2,
"accountId": "123456789010",
"interfaceId": "eni-abc123de",
"srcAddr": "192.0.2.0",
"dstAddr": "192.0.2.24",
"srcPort": 20641,
"dstPort": 22,
"protocol": 6,
"packets": 20,
"bytes": 4249,
"start": 1418530010,
"end": 1418530070,
"action": "ACCEPT",
"logStatus": "OK"
}
```
# parseToOCSF
Il `parseToOCSF` processore converte i log in eventi Open Cybersecurity Schema Framework (OCSF). OCSF è uno standard aperto che fornisce uno schema comune per i dati di sicurezza, che consente una migliore interoperabilità e analisi tra diversi strumenti e piattaforme di sicurezza.
Questo processore è particolarmente utile per i flussi di lavoro di analisi della sicurezza in cui è necessario standardizzare i formati di registro di vari AWS servizi in uno schema coerente per l'analisi a valle.
**Parametri**
`eventSource`(richiesto)
Speciifica il AWS servizio o il processo che produce gli eventi di registro da convertire. I valori validi sono:
+ `CloudTrail`- registri CloudTrail
+ `Route53Resolver`- Registri Route 53 Resolver
+ `VPCFlow`- Registri di flusso di Amazon VPC
+ `EKSAudit`- Registri di controllo di Amazon EKS
+ `AWSWAF`- registri AWS WAF
`ocsfVersion`(richiesto)
Speciifica quale versione dello schema OCSF utilizzare per gli eventi di registro trasformati. Versioni attualmente supportate: `V1.1, V1.5`
`mappingVersion` (facoltativo)
Specifica la versione di mappatura delle trasformazioni OCSF. Controlla quale logica di trasformazione viene applicata durante la conversione dei log in formato OCSF. Se non specificato, utilizza l'ultima versione disponibile al momento della creazione della politica. Le politiche esistenti non vengono aggiornate automaticamente quando vengono rilasciate nuove versioni di mappatura. Ultima versione attuale:`v1.5.0`.
**Nota:** Non supportato quando lo `ocsfVersion` è`V1.1`.
`source` (facoltativo)
Il percorso del campo nel registro dell'evento che desideri analizzare. Se omesso, viene analizzato l'intero messaggio di registro.
**Esempio**
L'esempio seguente mostra come utilizzare per `parseToOCSF` convertire i log di flusso VPC in formato OCSF:
```
{
"parseToOCSF": {
"eventSource": "VPCFlow",
"ocsfVersion": "V1.1"
}
}
```
L'esempio seguente mostra come specificare una particolare versione di mappatura per un comportamento di trasformazione coerente:
```
{
"parseToOCSF": {
"eventSource": "CloudTrail",
"ocsfVersion": "V1.5",
"mappingVersion": "v1.5.0"
}
}
```
# Processori di mutazione delle stringhe
Questa sezione contiene informazioni sui processori di mutazione delle stringhe che è possibile utilizzare con un trasformatore di eventi di registro.
**Contents**
+ [lowerCaseString](#CloudWatch-Logs-Transformation-lowerCaseString)
+ [upperCaseString](#CloudWatch-Logs-Transformation-upperCaseString)
+ [SplitString](#CloudWatch-Logs-Transformation-splitString)
+ [Stringa sostitutiva](#CloudWatch-Logs-Transformation-substituteString)
+ [TrimString](#CloudWatch-Logs-Transformation-trimString)
## lowerCaseString
Il `lowerCaseString` processore converte una stringa nella sua versione minuscola.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| Con chiavi | Un elenco di chiavi da convertire in lettere minuscole | Sì | | Numero massimo di voci: 10 |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key": "INNER_VALUE"
}
}
```
La configurazione del trasformatore è questa, utilizzata `lowerCaseString` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"lowerCaseString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
## upperCaseString
Il `upperCaseString` processore converte una stringa nella sua versione maiuscola.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| Con chiavi | Un elenco di chiavi da convertire in lettere maiuscole | Sì | | Numero massimo di voci: 10 |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configurazione del trasformatore è questa, utilizzata `upperCaseString` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"upperCaseString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {
"inner_key": "INNER_VALUE"
}
}
```
## SplitString
Il `splitString` processore è un tipo di processore di mutazione di stringhe che divide un campo in un array utilizzando un carattere delimitante.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| voci | Matrice di voci. Ogni elemento dell'array deve contenere source delimiter campi. | Sì | | Numero massimo di iscrizioni: 10 |
| origine | La chiave del valore del campo da dividere | Sì | | Lunghezza massima: 128. |
| delimitatore | La stringa delimitatrice su cui dividere il valore del campo | Sì | | Lunghezza massima: 128. |
**Esempio 1**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configurazione del trasformatore è questa, utilizzata `splitString` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"splitString": {
"entries": [
{
"source": "outer_key.inner_key",
"delimiter": "_"
}
]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {
"inner_key": [
"inner",
"value"
]
}
}
```
**Esempio 2**
Il delimitatore su cui dividere la stringa può contenere più caratteri.
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key": "item1, item2, item3"
}
}
```
La configurazione del trasformatore è la seguente:
```
[
{
"parseJSON": {}
},
{
"splitString": {
"entries": [
{
"source": "outer_key.inner_key",
"delimiter": ", "
}
]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {
"inner_key": [
"item1",
"item2",
"item3"
]
}
}
```
## Stringa sostitutiva
Il `substituteString` processore è un tipo di processore di mutazione di stringhe che abbina il valore di una chiave a un'espressione regolare e sostituisce tutte le corrispondenze con una stringa sostitutiva.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| voci | Matrice di voci. Ogni elemento dell'array deve contenere source to campi e. from | Sì | | Numero massimo di iscrizioni: 10 |
| origine | La chiave del campo da modificare | Sì | | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| from | La stringa di espressioni regolari da sostituire. I caratteri regex speciali come [e] devono essere evitati usando\$1\$1 quando si usano le virgolette doppie e con\$1 quando si usano le virgolette singole o quando sono configurati da. Console di gestione AWS Per ulteriori informazioni, vedere [Class Pattern](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html) sul sito Web di Oracle. È possibile inserire un pattern `(...)` per creare un gruppo di acquisizione numerato e creare gruppi di acquisizione `(?P...)` denominati a cui è possibile fare riferimento nel campo. `to` | Sì | | Lunghezza massima: 128. |
| in | È possibile utilizzare la stringa da sostituire per ogni corrispondenza di Backreference ai gruppi di from acquisizione. Usa il modulo \$1n per gruppi numerati come \$11 e \$1\$1group\$1name\$1 usalo per gruppi denominati come \$1. \$1my\$1group\$1 > | Sì | | Lunghezza massima: 128. Numero massimo di riferimenti retrospettivi: 10 Numero massimo di riferimenti retrospettivi duplicati: 2 |
**Esempio 1**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key1": "[]",
"inner_key2": "123-345-567",
"inner_key3": "A cat takes a catnap."
}
}
```
La configurazione del trasformatore è questa, utilizzata `substituteString` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"substituteString": {
"entries": [
{
"source": "outer_key.inner_key1",
"from": "\\[\\]",
"to": "value1"
},
{
"source": "outer_key.inner_key2",
"from": "[0-9]{3}-[0-9]{3}-[0-9]{3}",
"to": "xxx-xxx-xxx"
},
{
"source": "outer_key.inner_key3",
"from": "cat",
"to": "dog"
}
]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {
"inner_key1": "value1",
"inner_key2": "xxx-xxx-xxx",
"inner_key3": "A dog takes a dognap."
}
}
```
**Esempio 2**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key1": "Tom, Dick, and Harry",
"inner_key2": "arn:aws:sts::123456789012:assumed-role/MyImportantRole/MySession"
}
}
```
La configurazione del trasformatore è questa, utilizzata `substituteString` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"substituteString": {
"entries": [
{
"source": "outer_key.inner_key1",
"from": "(\w+), (\w+), and (\w+)",
"to": "$1 and $3"
},
{
"source": "outer_key.inner_key2",
"from": "^arn:aws:sts::(?P\\d{12}):assumed-role/(?P[\\w+=,.@-]+)/(?P[\\w+=,.@-]+)$",
"to": "${account_id}:${role_name}:${role_session_name}"
}
]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {
"inner_key1": "Tom and Harry",
"inner_key2": "123456789012:MyImportantRole:MySession"
}
}
```
## TrimString
Il `trimString` processore rimuove gli spazi bianchi dall'inizio e dalla fine di una chiave.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| Con chiavi | Un elenco di tasti da tagliare | Sì | | Numero massimo di iscrizioni: 10 |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key": " inner_value "
}
}
```
La configurazione del trasformatore è questa, utilizzata `trimString` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"trimString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
# Processori JSON con mutazione
Questa sezione contiene informazioni sui processori di mutazione JSON che è possibile utilizzare con un trasformatore di eventi di registro.
**Contents**
+ [AddKeys](#CloudWatch-Logs-Transformation-addKeys)
+ [DeleteKeys](#CloudWatch-Logs-Transformation-deleteKeys)
+ [moveKeys](#CloudWatch-Logs-Transformation-moveKeys)
+ [RenameKeys](#CloudWatch-Logs-Transformation-renameKeys)
+ [CopyValue](#CloudWatch-Logs-Transformation-copyValue)
+ [listToMap](#CloudWatch-Logs-Transformation-listToMap)
## AddKeys
Utilizzate il `addKeys` processore per aggiungere nuove coppie chiave-valore all'evento di registro.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| voci | Matrice di voci. Ogni elemento dell'array può contenere key overwriteIfExists campi e. value | Sì | | Numero massimo di iscrizioni: 5 |
| Chiave | La chiave della nuova voce da aggiungere | Sì | | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| value | Il valore della nuova voce da aggiungere | Sì | | Lunghezza massima: 256 |
| overwriteIfExists | Se lo imposti sutrue, il valore esistente viene sovrascritto se key già presente nell'evento. Il valore predefinito è false. | No | false | Nessun limite |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configurazione del trasformatore è questa, utilizzata `addKeys` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"addKeys": {
"entries": [
{
"key": "outer_key.new_key",
"value": "new_value"
}
]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {
"inner_key": "inner_value",
"new_key": "new_value"
}
}
```
## DeleteKeys
Usa il `deleteKeys` processore per eliminare i campi da un evento di registro. Questi campi possono includere coppie chiave-valore.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| Con chiavi | L'elenco delle chiavi da eliminare. | Sì | Nessun limite | Numero massimo di iscrizioni: 5 |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configurazione del trasformatore è questa, utilizzata `deleteKeys` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"deleteKeys": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {}
}
```
## moveKeys
Usa il `moveKeys` processore per spostare una chiave da un campo all'altro.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| voci | Matrice di voci. Ogni elemento dell'array può contenere source overwriteIfExists campi e. target | Sì | | Numero massimo di iscrizioni: 5 |
| origine | La chiave per muoversi | Sì | | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| target | La chiave verso cui passare | Sì | | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| overwriteIfExists | Se lo impostate sutrue, il valore esistente viene sovrascritto se key già presente nell'evento. Il valore predefinito è false. | No | false | Nessun limite |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key1": {
"inner_key1": "inner_value1"
},
"outer_key2": {
"inner_key2": "inner_value2"
}
}
```
La configurazione del trasformatore è questa, utilizzata `moveKeys` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"moveKeys": {
"entries": [
{
"source": "outer_key1.inner_key1",
"target": "outer_key2"
}
]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key1": {},
"outer_key2": {
"inner_key2": "inner_value2",
"inner_key1": "inner_value1"
}
}
```
## RenameKeys
Usa il `renameKeys` processore per rinominare le chiavi in un evento di registro.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| voci | Matrice di voci. Ogni elemento dell'array può contenere key overwriteIfExists campi e. target | Sì | Nessun limite | Numero massimo di iscrizioni: 5 |
| Chiave | La chiave per rinominare | Sì | Nessun limite | Lunghezza massima: 128. |
| target | Il nuovo nome della chiave | Sì | Nessun limite | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| overwriteIfExists | Se lo impostate sutrue, il valore esistente viene sovrascritto se key già presente nell'evento. Il valore predefinito è false. | No | false | Nessun limite |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configurazione del trasformatore è questa, utilizzata `renameKeys` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"renameKeys": {
"entries": [
{
"key": "outer_key",
"target": "new_key"
}
]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"new_key": {
"inner_key": "inner_value"
}
}
```
## CopyValue
Usa il `copyValue` processore per copiare i valori all'interno di un evento di registro. È inoltre possibile utilizzare questo processore per aggiungere metadati agli eventi di registro, copiando i valori delle seguenti chiavi di metadati negli eventi di registro:`@logGroupName`,,,`@logGroupStream`. `@accountId` `@regionName` Questo è illustrato nell'esempio seguente.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| voci | Matrice di voci. Ogni elemento dell'array può contenere source overwriteIfExists campi e. target | Sì | | Numero massimo di iscrizioni: 5 |
| origine | La chiave da copiare | Sì | | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| target | La chiave in cui copiare il valore | Sì | Nessun limite | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| overwriteIfExists | Se lo impostate sutrue, il valore esistente viene sovrascritto se key già presente nell'evento. Il valore predefinito è false. | No | false | Nessun limite |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configurazione del trasformatore è questa, utilizzata `copyValue` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"copyValue": {
"entries": [
{
"key": "outer_key.new_key",
"target": "new_key"
},
{
"source": "@logGroupName",
"target": "log_group_name"
},
{
"source": "@logGroupStream",
"target": "log_group_stream"
},
{
"source": "@accountId",
"target": "account_id"
},
{
"source": "@regionName",
"target": "region_name"
}
]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": {
"inner_key": "inner_value"
},
"new_key": "inner_value",
"log_group_name": "myLogGroupName",
"log_group_stream": "myLogStreamName",
"account_id": "012345678912",
"region_name": "us-east-1"
}
```
## listToMap
Il `listToMap` processore prende un elenco di oggetti che contengono campi chiave e li converte in una mappa di chiavi di destinazione.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| origine | La chiave contiene un elenco di oggetti che verranno convertiti in una mappa ProcessingEvent | Sì | | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| Chiave | La chiave dei campi da estrarre come chiavi nella mappa generata | Sì | | Lunghezza massima: 128. |
| ValueKey | Se viene specificato, i valori specificati in questo parametro verranno estratti dagli source oggetti e inseriti nei valori della mappa generata. Altrimenti, gli oggetti originali nell'elenco dei sorgenti verranno inseriti nei valori della mappa generata. | No | | Lunghezza massima: 128. |
| target | La chiave del campo che conterrà la mappa generata | No | Nodo radice | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| flatten | Un valore booleano per indicare se l'elenco verrà appiattito in singoli elementi o se i valori nella mappa generata saranno elenchi. Per impostazione predefinita, i valori per le chiavi corrispondenti saranno rappresentati in un array. `flatten``true`Impostare su per convertire l'array in un singolo valore basato sul valore di`flattenedElement`. | No | false | |
| Elemento appiattito | Se impostate su flattentrue, utilizzate flattenedElement per specificare quale elemento, first olast, conservare. | Obbligatorio quando `flatten` è impostato su `true` | | Il valore può essere solo first o last |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"outer_key": [
{
"inner_key": "a",
"inner_value": "val-a"
},
{
"inner_key": "b",
"inner_value": "val-b1"
},
{
"inner_key": "b",
"inner_value": "val-b2"
},
{
"inner_key": "c",
"inner_value": "val-c"
}
]
}
```
**Trasformatore per il caso d'uso 1:** `flatten` è `false`
```
[
{
"parseJSON": {}
},
{
"listToMap": {
"source": "outer_key"
"key": "inner_key",
"valueKey": "inner_value",
"flatten": false
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": [
{
"inner_key": "a",
"inner_value": "val-a"
},
{
"inner_key": "b",
"inner_value": "val-b1"
},
{
"inner_key": "b",
"inner_value": "val-b2"
},
{
"inner_key": "c",
"inner_value": "val-c"
}
],
"a": [
"val-a"
],
"b": [
"val-b1",
"val-b2"
],
"c": [
"val-c"
]
}
```
**Trasformatore per il caso d'uso 2:** `flatten` è `true` ed `flattenedElement` è `first`
```
[
{
"parseJSON": {}
},
{
"listToMap": {
"source": "outer_key"
"key": "inner_key",
"valueKey": "inner_value",
"flatten": true,
"flattenedElement": "first"
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": [
{
"inner_key": "a",
"inner_value": "val-a"
},
{
"inner_key": "b",
"inner_value": "val-b1"
},
{
"inner_key": "b",
"inner_value": "val-b2"
},
{
"inner_key": "c",
"inner_value": "val-c"
}
],
"a": "val-a",
"b": "val-b1",
"c": "val-c"
}
```
**Trasformatore per il caso d'uso 3:** `flatten` è `true` ed `flattenedElement` è `last`
```
[
{
"parseJSON": {}
},
{
"listToMap": {
"source": "outer_key"
"key": "inner_key",
"valueKey": "inner_value",
"flatten": true,
"flattenedElement": "last"
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"outer_key": [
{
"inner_key": "a",
"inner_value": "val-a"
},
{
"inner_key": "b",
"inner_value": "val-b1"
},
{
"inner_key": "b",
"inner_value": "val-b2"
},
{
"inner_key": "c",
"inner_value": "val-c"
}
],
"a": "val-a",
"b": "val-b2",
"c": "val-c"
}
```
# Processori di conversione di tipi di dati
Questa sezione contiene informazioni sui processori di conversione dei tipi di dati che è possibile utilizzare con un trasformatore di eventi di registro.
**Contents**
+ [TypeConverter](#CloudWatch-Logs-Transformation-typeConverter)
+ [DateTimeConverter](#CloudWatch-Logs-Transformation-datetimeConverter)
## TypeConverter
Utilizzate il `typeConverter` processore per convertire un tipo di valore associato alla chiave specificata nel tipo specificato. È un processore di casting che modifica i tipi dei campi specificati. I valori possono essere convertiti in uno dei seguenti tipi di dati:`integer`,, `double` e. `string` `boolean`
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| voci | Matrice di voci. Ogni elemento dell'array deve contenere key type campi. | Sì | | Numero massimo di iscrizioni: 10 |
| Chiave | La chiave con il valore da convertire in un tipo diverso | Sì | | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| tipo | Il tipo in cui eseguire la conversione. I valori validi sono integerdouble, string eboolean. | Sì | | |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{
"name": "value",
"status": "200"
}
```
La configurazione del trasformatore è questa, utilizzata `typeConverter` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"typeConverter": {
"entries": [
{
"key": "status",
"type": "integer"
}
]
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"name": "value",
"status": 200
}
```
## DateTimeConverter
Utilizzate il `datetimeConverter` processore per convertire una stringa datetime in un formato specificato dall'utente.
| Campo | Description | Obbligatorio? | Predefinita | Limits |
| --- | --- | --- | --- | --- |
| origine | La chiave a cui applicare la conversione della data. | Sì | | Numero massimo di iscrizioni: 10 |
| Match Patterns | Un elenco di modelli da abbinare al campo source | Sì | | Numero massimo di iscrizioni: 5 |
| target | Il campo JSON in cui memorizzare il risultato. | Sì | | Lunghezza massima: 128. Profondità massima della chiave annidata: 3 |
| Formato di destinazione | Il formato datetime da utilizzare per i dati convertiti nel campo di destinazione. | No | ` yyyy-MM-dd'T'HH:mm:ss.SSS'Z` | Lunghezza massima: 64 |
| Fuso orario di origine | Il fuso orario del campo sorgente. Per un elenco dei valori possibili, consulta [Java Supported Zone Ids and Offsets](https://howtodoinjava.com/java/date-time/supported-zone-ids-offsets/#3-java-supported-zone-ids-and-offsets). | No | UTC | Lunghezza minima:1 |
| Fuso orario di destinazione | Il fuso orario del campo di destinazione. Per un elenco dei valori possibili, consulta [Java Supported Zone Ids and Offsets](https://howtodoinjava.com/java/date-time/supported-zone-ids-offsets/#3-java-supported-zone-ids-and-offsets). | No | UTC | Lunghezza minima:1 |
| locale | La localizzazione del campo sorgente. Per un elenco di valori possibili, vedete [Metodo Locale getAvailableLocales () in Java con esempi](https://www.geeksforgeeks.org/locale-getavailablelocales-method-in-java-with-examples/). | Sì | | Lunghezza minima:1 |
**Esempio**
Prendiamo il seguente esempio di evento di registro:
```
{"german_datetime": "Samstag 05. Dezember 1998 11:00:00"}
```
La configurazione del trasformatore è questa, utilizzata `dateTimeConverter` con`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"dateTimeConverter": {
"source": "german_datetime",
"target": "target_1",
"locale": "de",
"matchPatterns": ["EEEE dd. MMMM yyyy HH:mm:ss"],
"sourceTimezone": "Europe/Berlin",
"targetTimezone": "America/New_York",
"targetFormat": "yyyy-MM-dd'T'HH:mm:ss z"
}
}
]
```
L'evento di registro trasformato sarebbe il seguente.
```
{
"german_datetime": "Samstag 05. Dezember 1998 11:00:00",
"target_1": "1998-12-05T17:00:00 MEZ"
}
```
# Metriche ed errori di trasformazione
CloudWatch Logs pubblica le metriche di trasformazione su. CloudWatch Queste metriche includono`TransformedLogEvents`, e. `TransformedBytes` `TransformationErrors` Per ulteriori informazioni, consulta [Metriche e dimensioni del trasformatore di log](CloudWatch-Logs-Monitoring-CloudWatch-Metrics.md#CloudWatchLogs-Transformer-Metrics).
Ogni volta che CloudWatch Logs tenta e fallisce di trasformare un evento di registro, aggiunge un campo di `@transformationError` sistema a quell'evento di registro. Quando esegui una query di CloudWatch Logs Insights, vedrai questo campo in tutti gli eventi di registro che hanno avuto un errore di trasformazione. È possibile eseguire una query per questo campo con una query in `filter ispresent(@transformationError)` modo da trovare tutti gli eventi di trasformazione non riusciti.