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à.

# AWS WAF Registri delle interrogazioni
<a name="waf-logs"></a>

AWS WAF è un firewall per applicazioni Web che consente di monitorare e controllare le richieste HTTP e HTTPS che le applicazioni Web protette ricevono dai client. È possibile definire come gestire le richieste Web configurando le regole all'interno di una lista di controllo degli accessi AWS WAF Web (ACL). Si protegge quindi un'applicazione Web associandovi un'ACL Web. Esempi di risorse per applicazioni Web con cui puoi proteggerti AWS WAF includono CloudFront distribuzioni Amazon, Amazon API Gateway APIs REST e Application Load Balancers. *Per ulteriori informazioni in merito AWS WAF, consulta la guida per [AWS WAF](https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html)gli AWS WAF sviluppatori.*

AWS WAF i log includono informazioni sul traffico analizzato dall'ACL Web, ad esempio l'ora in cui è AWS WAF stata ricevuta la richiesta dalla AWS risorsa, informazioni dettagliate sulla richiesta e l'azione relativa alla regola a cui corrisponde ogni richiesta.

È possibile configurare un ACL AWS WAF Web per pubblicare i log su una delle diverse destinazioni, dove è possibile interrogarli e visualizzarli. *Per ulteriori informazioni sulla configurazione della registrazione Web ACL e sul contenuto dei AWS WAF log, consulta la sezione Registrazione del traffico ACL [AWS WAF Web nella guida per gli sviluppatori](https://docs.aws.amazon.com/waf/latest/developerguide/logging.html).AWS WAF *

Per informazioni su come utilizzare Athena per analizzare AWS WAF i log per ottenere informazioni sul rilevamento delle minacce e sui potenziali attacchi alla sicurezza, consulta il post del blog AWS Networking & Content Delivery [Come usare le query Amazon Athena per analizzare AWS WAF i log e fornire la visibilità necessaria per](https://aws.amazon.com/blogs/networking-and-content-delivery/how-to-use-amazon-athena-queries-to-analyze-aws-waf-logs-and-provide-the-visibility-needed-for-threat-detection/) il rilevamento delle minacce.

Per un esempio di come aggregare AWS WAF i log in un repository centrale di data lake e interrogarli con Athena, consulta il post del blog AWS Big Data [Analyzing logs AWS WAF with Service OpenSearch , Amazon Athena](https://aws.amazon.com/blogs/big-data/analyzing-aws-waf-logs-with-amazon-es-amazon-athena-and-amazon-quicksight/) e Quick.

Questo argomento fornisce esempi di istruzioni `CREATE TABLE` per la proiezione delle partizioni, il partizionamento manuale e uno che non utilizza alcun partizionamento.

**Nota**  
Le istruzioni `CREATE TABLE` in questo argomento possono essere utilizzate per i registri AWS WAF v1 e v2. In v1, il campo `webaclid` contiene un ID. In v2, il campo `webaclid` contiene un ARN completo. Le istruzioni `CREATE TABLE` trattano questo contenuto in modo agnostico usando il tipo di dati `string`.

**Topics**
+ [Crea una tabella per i log AWS WAF S3 in Athena usando la proiezione delle partizioni](create-waf-table-partition-projection.md)
+ [Crea una tabella per i log AWS WAF S3 in Athena usando la partizione manuale](create-waf-table-manual-partition.md)
+ [Crea una tabella per i log senza partizionamento AWS WAF](create-waf-table.md)
+ [Interrogazioni di esempio per i log AWS WAF](query-examples-waf-logs.md)

# Crea una tabella per i log AWS WAF S3 in Athena usando la proiezione delle partizioni
<a name="create-waf-table-partition-projection"></a>

[Poiché AWS WAF i log hanno una struttura nota il cui schema di partizione è possibile specificare in anticipo, è possibile ridurre il tempo di esecuzione delle query e automatizzare la gestione delle partizioni utilizzando la funzionalità di proiezione delle partizioni Athena.](partition-projection.md) La proiezione delle partizioni aggiunge automaticamente nuove partizioni man mano che vengono aggiunti nuovi dati. Ciò elimina la necessità di aggiungere manualmente le partizioni utilizzando `ALTER TABLE ADD PARTITION`. 

L'`CREATE TABLE`istruzione di esempio seguente utilizza automaticamente la proiezione delle partizioni nei AWS WAF log da una data specificata fino ad oggi per quattro diverse regioni. AWS La clausola `PARTITION BY` in questo esempio esegue la partizione per regione e per data, ma è possibile modificarla in base alle proprie esigenze. Modifica i campi secondo necessità in base all'output del log. Nelle `storage.location.template` clausole `LOCATION` and, sostituisci i *AWS\$1ACCOUNT\$1NUMBER* segnaposto *amzn-s3-demo-bucket* and con valori che identificano la posizione del bucket Amazon S3 dei log. AWS WAF Per`projection.day.range`, sostituisci*2021*/*01*/*01*con la data di inizio che desideri utilizzare. Dopo aver eseguito la query con esito positivo, è possibile eseguire query sulla tabella. Non è necessario eseguire `ALTER TABLE ADD PARTITION` per caricare le partizioni. 

```
CREATE EXTERNAL TABLE `waf_logs_partition_projection`(
  `timestamp` bigint, 
  `formatversion` int, 
  `webaclid` string, 
  `terminatingruleid` string, 
  `terminatingruletype` string, 
  `action` string, 
  `terminatingrulematchdetails` array<struct<conditiontype:string,sensitivitylevel:string,location:string,matcheddata:array<string>>>, 
  `httpsourcename` string, 
  `httpsourceid` string, 
  `rulegrouplist` array<struct<rulegroupid:string,terminatingrule:struct<ruleid:string,action:string,rulematchdetails:array<struct<conditiontype:string,sensitivitylevel:string,location:string,matcheddata:array<string>>>>,nonterminatingmatchingrules:array<struct<ruleid:string,action:string,overriddenaction:string,rulematchdetails:array<struct<conditiontype:string,sensitivitylevel:string,location:string,matcheddata:array<string>>>,challengeresponse:struct<responsecode:string,solvetimestamp:string>,captcharesponse:struct<responsecode:string,solvetimestamp:string>>>,excludedrules:string>>, 
  `ratebasedrulelist` array<struct<ratebasedruleid:string,limitkey:string,maxrateallowed:int>>, 
  `nonterminatingmatchingrules` array<struct<ruleid:string,action:string,rulematchdetails:array<struct<conditiontype:string,sensitivitylevel:string,location:string,matcheddata:array<string>>>,challengeresponse:struct<responsecode:string,solvetimestamp:string>,captcharesponse:struct<responsecode:string,solvetimestamp:string>>>, 
  `requestheadersinserted` array<struct<name:string,value:string>>, 
  `responsecodesent` string, 
  `httprequest` struct<clientip:string,country:string,headers:array<struct<name:string,value:string>>,uri:string,args:string,httpversion:string,httpmethod:string,requestid:string,fragment:string,scheme:string,host:string>,
  `labels` array<struct<name:string>>, 
  `captcharesponse` struct<responsecode:string,solvetimestamp:string,failurereason:string>, 
  `challengeresponse` struct<responsecode:string,solvetimestamp:string,failurereason:string>, 
  `ja3fingerprint` string, 
  `ja4fingerprint` string, 
  `oversizefields` string, 
  `requestbodysize` int, 
  `requestbodysizeinspectedbywaf` int)
  PARTITIONED BY ( 
   `log_time` string)
ROW FORMAT SERDE 
  'org.openx.data.jsonserde.JsonSerDe' 
STORED AS INPUTFORMAT 
  'org.apache.hadoop.mapred.TextInputFormat' 
OUTPUTFORMAT 
  'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
  's3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/testui/'
TBLPROPERTIES (
 'projection.enabled'='true',
  'projection.log_time.format'='yyyy/MM/dd/HH/mm',
  'projection.log_time.interval'='1',
  'projection.log_time.interval.unit'='minutes',
  'projection.log_time.range'='2025/01/01/00/00,NOW',
  'projection.log_time.type'='date',
  'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/testui/${log_time}')
```

**Nota**  
Il formato del percorso nella `LOCATION` clausola dell'esempio è standard ma può variare in base alla AWS WAF configurazione implementata. Ad esempio, il percorso dei AWS WAF log di esempio seguente riguarda una CloudFront distribuzione:   

```
s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/cloudfronyt/2025/01/01/00/00/
```
[Se riscontri problemi durante la creazione o l'interrogazione della tabella AWS WAF dei log, conferma la posizione dei dati di registro o del contatto. Supporto](https://console.aws.amazon.com/support/home/)

Per maggiori informazioni sulla proiezione delle partizioni, consulta [Proiezione delle partizioni con Amazon Athena](partition-projection.md).

# Crea una tabella per i log AWS WAF S3 in Athena usando la partizione manuale
<a name="create-waf-table-manual-partition"></a>

Questa sezione descrive come creare una tabella per i AWS WAF log utilizzando la partizione manuale.

Nelle `storage.location.template` clausole `LOCATION` and, sostituisci i *AWS\$1ACCOUNT\$1NUMBER* segnaposto *amzn-s3-demo-bucket* and con valori che identificano la posizione del bucket Amazon S3 dei log. AWS WAF 

```
CREATE EXTERNAL TABLE `waf_logs_manual_partition`(
  `timestamp` bigint, 
  `formatversion` int, 
  `webaclid` string, 
  `terminatingruleid` string, 
  `terminatingruletype` string, 
  `action` string, 
  `terminatingrulematchdetails` array<struct<conditiontype:string,sensitivitylevel:string,location:string,matcheddata:array<string>>>, 
  `httpsourcename` string, 
  `httpsourceid` string, 
  `rulegrouplist` array<struct<rulegroupid:string,terminatingrule:struct<ruleid:string,action:string,rulematchdetails:array<struct<conditiontype:string,sensitivitylevel:string,location:string,matcheddata:array<string>>>>,nonterminatingmatchingrules:array<struct<ruleid:string,action:string,overriddenaction:string,rulematchdetails:array<struct<conditiontype:string,sensitivitylevel:string,location:string,matcheddata:array<string>>>,challengeresponse:struct<responsecode:string,solvetimestamp:string>,captcharesponse:struct<responsecode:string,solvetimestamp:string>>>,excludedrules:string>>, 
  `ratebasedrulelist` array<struct<ratebasedruleid:string,limitkey:string,maxrateallowed:int>>, 
  `nonterminatingmatchingrules` array<struct<ruleid:string,action:string,rulematchdetails:array<struct<conditiontype:string,sensitivitylevel:string,location:string,matcheddata:array<string>>>,challengeresponse:struct<responsecode:string,solvetimestamp:string>,captcharesponse:struct<responsecode:string,solvetimestamp:string>>>, 
  `requestheadersinserted` array<struct<name:string,value:string>>, 
  `responsecodesent` string, 
  `httprequest` struct<clientip:string,country:string,headers:array<struct<name:string,value:string>>,uri:string,args:string,httpversion:string,httpmethod:string,requestid:string,fragment:string,scheme:string,host:string>, 
  `labels` array<struct<name:string>>, 
  `captcharesponse` struct<responsecode:string,solvetimestamp:string,failurereason:string>, 
  `challengeresponse` struct<responsecode:string,solvetimestamp:string,failurereason:string>, 
  `ja3fingerprint` string, 
  `ja4fingerprint` string, 
  `oversizefields` string, 
  `requestbodysize` int, 
  `requestbodysizeinspectedbywaf` int)
  PARTITIONED BY ( `year` string, `month` string, `day` string, `hour` string, `min` string)
ROW FORMAT SERDE 
  'org.openx.data.jsonserde.JsonSerDe' 
STORED AS INPUTFORMAT 
  'org.apache.hadoop.mapred.TextInputFormat' 
OUTPUTFORMAT 
  'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
  's3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/webacl/'
```

# Crea una tabella per i log senza partizionamento AWS WAF
<a name="create-waf-table"></a>

Questa sezione descrive come creare una tabella per i AWS WAF log senza partizionamento o proiezione delle partizioni.

**Nota**  
Per motivi di prestazioni e costi, non è consigliabile utilizzare uno schema non partizionato per le query. Per ulteriori informazioni, consulta i [10 migliori consigli per l'ottimizzazione delle prestazioni per Amazon](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/) Athena AWS nel blog Big Data.

**Per creare la tabella AWS WAF**

1. Copiare e incollare la seguente istruzione DDL nella console Athena. Modifica i campi secondo necessità in base all'output del log. Modifica il parametro `LOCATION` per il bucket Amazon S3 in cui sono archiviati i registri.

   Questa query utilizza il metodo [OpenX JSON SerDe](openx-json-serde.md).
**Nota**  
 SerDe Si aspetta che ogni documento JSON si trovi su una singola riga di testo senza caratteri di terminazione di riga che separano i campi del record. Se il testo JSON è in un bel formato di stampa, potresti ricevere un messaggio di errore come HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object o HIVE\$1CURSOR\$1ERROR:: Unexpected end-of-input: expected: expected close marker for OBJECT quando tenti di interrogare la tabella dopo averla JsonParseException creata. Per ulteriori informazioni, consulta [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) nella documentazione di SerDe OpenX su. GitHub 

   ```
   CREATE EXTERNAL TABLE `waf_logs`(
     `timestamp` bigint,
     `formatversion` int,
     `webaclid` string,
     `terminatingruleid` string,
     `terminatingruletype` string,
     `action` string,
     `terminatingrulematchdetails` array <
                                       struct <
                                           conditiontype: string,
                                           sensitivitylevel: string,
                                           location: string,
                                           matcheddata: array < string >
                                             >
                                        >,
     `httpsourcename` string,
     `httpsourceid` string,
     `rulegrouplist` array <
                         struct <
                             rulegroupid: string,
                             terminatingrule: struct <
                                                 ruleid: string,
                                                 action: string,
                                                 rulematchdetails: array <
                                                                      struct <
                                                                          conditiontype: string,
                                                                          sensitivitylevel: string,
                                                                          location: string,
                                                                          matcheddata: array < string >
                                                                             >
                                                                       >
                                                   >,
                             nonterminatingmatchingrules: array <
                                                                 struct <
                                                                     ruleid: string,
                                                                     action: string,
                                                                     overriddenaction: string,
                                                                     rulematchdetails: array <
                                                                                          struct <
                                                                                              conditiontype: string,
                                                                                              sensitivitylevel: string,
                                                                                              location: string,
                                                                                              matcheddata: array < string >
                                                                                                 >
                                                                      >,
                                                                     challengeresponse: struct <
                                                                               responsecode: string,
                                                                               solvetimestamp: string
                                                                                 >,
                                                                     captcharesponse: struct <
                                                                               responsecode: string,
                                                                               solvetimestamp: string
                                                                                 >
                                                                       >
                                                                >,
                             excludedrules: string
                               >
                          >,
   `ratebasedrulelist` array <
                            struct <
                                ratebasedruleid: string,
                                limitkey: string,
                                maxrateallowed: int
                                  >
                             >,
     `nonterminatingmatchingrules` array <
                                       struct <
                                           ruleid: string,
                                           action: string,
                                           rulematchdetails: array <
                                                                struct <
                                                                    conditiontype: string,
                                                                    sensitivitylevel: string,
                                                                    location: string,
                                                                    matcheddata: array < string >
                                                                       >
                                                                >,
                                           challengeresponse: struct <
                                                               responsecode: string,
                                                               solvetimestamp: string
                                                                >,
                                           captcharesponse: struct <
                                                               responsecode: string,
                                                               solvetimestamp: string
                                                                >
                                             >
                                        >,
     `requestheadersinserted` array <
                                   struct <
                                       name: string,
                                       value: string
                                         >
                                    >,
     `responsecodesent` string,
     `httprequest` struct <
                       clientip: string,
                       country: string,
                       headers: array <
                                   struct <
                                       name: string,
                                       value: string
                                         >
                                    >,
                       uri: string,
                       args: string,
                       httpversion: string,
                       httpmethod: string,
                       requestid: string
                         >,
     `labels` array <
                  struct <
                      name: string
                        >
                   >,
     `captcharesponse` struct <
                           responsecode: string,
                           solvetimestamp: string,
                           failureReason: string
                             >,
     `challengeresponse` struct <
                           responsecode: string,
                           solvetimestamp: string,
                           failureReason: string
                           >,
     `ja3Fingerprint` string,
     `oversizefields` string,
     `requestbodysize` int,
     `requestbodysizeinspectedbywaf` int
   )
   ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
   STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'
   OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
   LOCATION 's3://amzn-s3-demo-bucket/prefix/'
   ```

1. Esegui l'istruzione `CREATE EXTERNAL TABLE` nell'editor di query della console Athena. Questo registra la tabella `waf_logs` e rende i dati in essa contenuti disponibili per le query da Athena.

# Interrogazioni di esempio per i log AWS WAF
<a name="query-examples-waf-logs"></a>

Molte delle seguenti query di esempio utilizzano la tabella di proiezione delle partizioni creata nella sezione precedente di questo documento. Modificare il nome della tabella, i valori delle colonne e altre variabili negli esempi in base alle proprie esigenze. Per migliorare le prestazioni delle query e ridurre i costi, aggiungere la colonna della partizione nella condizione del filtro.

**Topics**
+ [Conta i referrer, gli indirizzi IP o le regole corrispondenti](query-examples-waf-logs-count.md)
+ [Data e ora interrogare utilizzando data e ora](query-examples-waf-logs-date-time.md)
+ [Interrogazione per richieste o indirizzi bloccati](query-examples-waf-logs-blocked-requests.md)

# Conta i referrer, gli indirizzi IP o le regole corrispondenti
<a name="query-examples-waf-logs-count"></a>

Gli esempi di questa sezione richiedono il conteggio degli elementi di registro di interesse.
+ [Count the number of referrers that contain a specified term](#waf-example-count-referrers-with-specified-term)
+ [Count all matched IP addresses in the last 10 days that have matched excluded rules](#waf-example-count-matched-ip-addresses)
+ [Group all counted managed rules by the number of times matched](#waf-example-group-managed-rules-by-times-matched)
+ [Group all counted custom rules by number of times matched](#waf-example-group-custom-rules-by-times-matched)

**Example : Conta il numero di riferimenti contenenti un termine specificato**  
La query seguente conta il numero di riferimenti che contengono il termine "amazon" per l'intervallo di date specificato.  

```
WITH test_dataset AS 
  (SELECT header FROM waf_logs
    CROSS JOIN UNNEST(httprequest.headers) AS t(header) WHERE "date" >= '2021/03/01'
    AND "date" < '2021/03/31')
SELECT COUNT(*) referer_count 
FROM test_dataset 
WHERE LOWER(header.name)='referer' AND header.value LIKE '%amazon%'
```

**Example : Conta tutti gli indirizzi IP corrispondenti negli ultimi 10 giorni che hanno soddisfatto le regole escluse**  
La query seguente conteggia il numero di volte in cui l'indirizzo IP corrisponde alla regola esclusa nel gruppo di regole.   

```
WITH test_dataset AS 
  (SELECT * FROM waf_logs 
    CROSS JOIN UNNEST(rulegrouplist) AS t(allrulegroups))
SELECT 
  COUNT(*) AS count, 
  "httprequest"."clientip", 
  "allrulegroups"."excludedrules",
  "allrulegroups"."ruleGroupId"
FROM test_dataset 
WHERE allrulegroups.excludedrules IS NOT NULL AND from_unixtime(timestamp/1000) > now() - interval '10' day
GROUP BY "httprequest"."clientip", "allrulegroups"."ruleGroupId", "allrulegroups"."excludedrules"
ORDER BY count DESC
```

**Example : Raggruppa tutte le regole gestite conteggiate in base al numero di corrispondenze**  
Se hai impostato le azioni delle regole del gruppo di regole su Count nella configurazione Web ACL prima del 27 ottobre 2022, AWS WAF hai salvato le sostituzioni nell'ACL Web JSON come. `excludedRules` Ora, l'impostazione JSON per sovrascrivere una regola su Count è nelle impostazioni `ruleActionOverrides`. Per ulteriori informazioni, consulta [Sostituzione delle azioni nei gruppi di regole](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-rule-group-override-options.html) nella *Guida per gli sviluppatori di AWS WAF *. Per estrarre le regole gestite in modalità Count dalla nuova struttura di log, esegui una query su `nonTerminatingMatchingRules` nella sezione `ruleGroupList` anziché nel campo `excludedRules`, come nell'esempio seguente.  

```
SELECT
 count(*) AS count,
 httpsourceid,
 httprequest.clientip,
 t.rulegroupid, 
 t.nonTerminatingMatchingRules
FROM "waf_logs" 
CROSS JOIN UNNEST(rulegrouplist) AS t(t) 
WHERE action <> 'BLOCK' AND cardinality(t.nonTerminatingMatchingRules) > 0 
GROUP BY t.nonTerminatingMatchingRules, action, httpsourceid, httprequest.clientip, t.rulegroupid 
ORDER BY "count" DESC 
Limit 50
```

**Example : Raggruppa tutte le regole personalizzate contate in base al numero di corrispondenze**  
La seguente query raggruppa tutte le regole personalizzate contate in base al numero di volte in cui sono state confrontate.  

```
SELECT
  count(*) AS count,
         httpsourceid,
         httprequest.clientip,
         t.ruleid,
         t.action
FROM "waf_logs" 
CROSS JOIN UNNEST(nonterminatingmatchingrules) AS t(t) 
WHERE action <> 'BLOCK' AND cardinality(nonTerminatingMatchingRules) > 0 
GROUP BY t.ruleid, t.action, httpsourceid, httprequest.clientip 
ORDER BY "count" DESC
Limit 50
```

Per informazioni sui percorsi dei log per le regole personalizzate e i gruppi di regole gestiti, consulta [Controllo e regolazione](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-testing-activities.html) nella *Guida per gli sviluppatori di AWS WAF *.

# Data e ora interrogare utilizzando data e ora
<a name="query-examples-waf-logs-date-time"></a>

Gli esempi di questa sezione illustrano le query che utilizzano i valori di data e ora.
+ [Return the timestamp field in human-readable ISO 8601 format](#waf-example-return-human-readable-timestamp)
+ [Return records from the last 24 hours](#waf-example-return-records-last-24-hours)
+ [Return records for a specified date range and IP address](#waf-example-return-records-date-range-and-ip)
+ [For a specified date range, count the number of IP addresses in five minute intervals](#waf-example-count-ip-addresses-in-date-range)
+ [Count the number of X-Forwarded-For IP in the last 10 days](#waf-example-count-x-forwarded-for-ip)

**Example : Restituisci il campo timestamp in formato ISO 8601 leggibile dall'uomo**  
La seguente query utilizza le funzioni `from_unixtime` e `to_iso8601` per restituire il campo `timestamp` in formato ISO 8601 leggibile dalle persone (ad esempio, `2019-12-13T23:40:12.000Z` invece di `1576280412771`). La query restituisce anche il nome dell'origine HTTP, l'ID di origine e la richiesta.   

```
SELECT to_iso8601(from_unixtime(timestamp / 1000)) as time_ISO_8601,
       httpsourcename,
       httpsourceid,
       httprequest
FROM waf_logs
LIMIT 10;
```

**Example : Restituisci record delle ultime 24 ore**  
La query seguente utilizza un filtro nella clausola `WHERE` per restituire il nome dell'origine HTTP, l'ID origine HTTP e i campi di richiesta HTTP per i registri delle ultime 24 ore.  

```
SELECT to_iso8601(from_unixtime(timestamp/1000)) AS time_ISO_8601, 
       httpsourcename, 
       httpsourceid, 
       httprequest 
FROM waf_logs
WHERE from_unixtime(timestamp/1000) > now() - interval '1' day
LIMIT 10;
```

**Example : Restituisci i record per un intervallo di date e un indirizzo IP specificati**  
Nella query seguente sono elencati i registri in un intervallo di date specificato per un indirizzo IP client specificato.  

```
SELECT * 
FROM waf_logs 
WHERE httprequest.clientip='53.21.198.66' AND "date" >= '2021/03/01' AND "date" < '2021/03/31'
```

**Example : per un intervallo di date specificato, conta il numero di indirizzi IP in intervalli di cinque minuti**  
La query seguente conta, per un determinato intervallo di date, il numero di indirizzi IP in intervalli di cinque minuti.  

```
WITH test_dataset AS 
  (SELECT 
     format_datetime(from_unixtime((timestamp/1000) - ((minute(from_unixtime(timestamp / 1000))%5) * 60)),'yyyy-MM-dd HH:mm') AS five_minutes_ts,
     "httprequest"."clientip" 
     FROM waf_logs 
     WHERE "date" >= '2021/03/01' AND "date" < '2021/03/31')
SELECT five_minutes_ts,"clientip",count(*) ip_count 
FROM test_dataset 
GROUP BY five_minutes_ts,"clientip"
```

**Example — Conta il numero di X-Forwarded-For IP negli ultimi 10 giorni**  
La seguente query filtra le intestazioni delle richieste e conta il numero di X-Forwarded-For IP negli ultimi 10 giorni.  

```
WITH test_dataset AS
  (SELECT header
   FROM waf_logs
   CROSS JOIN UNNEST (httprequest.headers) AS t(header)
   WHERE from_unixtime("timestamp"/1000) > now() - interval '10' DAY) 
SELECT header.value AS ip,
       count(*) AS COUNT 
FROM test_dataset 
WHERE header.name='X-Forwarded-For' 
GROUP BY header.value 
ORDER BY COUNT DESC
```

Per ulteriori informazioni sulle funzioni data e ora, consulta [Funzioni e operatori di data e ora](https://trino.io/docs/current/functions/datetime.html) nella documentazione Trino.

# Interrogazione per richieste o indirizzi bloccati
<a name="query-examples-waf-logs-blocked-requests"></a>

Gli esempi di questa sezione eseguono query per richieste o indirizzi bloccati.
+ [Extract the top 100 IP addresses blocked by a specified rule type](#waf-example-extract-top-100-blocked-ip-by-rule)
+ [Count the number of times a request from a specified country has been blocked](#waf-example-count-request-blocks-from-country)
+ [Count the number of times a request has been blocked, grouping by specific attributes](#waf-example-count-request-blocks-by-attribute)
+ [Count the number of times a specific terminating rule ID has been matched](#waf-example-count-terminating-rule-id-matches)
+ [Retrieve the top 100 IP addresses blocked during a specified date range](#waf-example-top-100-ip-addresses-blocked-for-date-range)

**Example : Estrai i primi 100 indirizzi IP bloccati da un tipo di regola specificato**  
La query seguente estrae e conta i primi 100 indirizzi IP bloccati dalla regola di terminazione `RATE_BASED` durante l'intervallo di date specificato.  

```
SELECT COUNT(httpRequest.clientIp) as count,
httpRequest.clientIp
FROM waf_logs
WHERE terminatingruletype='RATE_BASED' AND action='BLOCK' and "date" >= '2021/03/01'
AND "date" < '2021/03/31'
GROUP BY httpRequest.clientIp
ORDER BY count DESC
LIMIT 100
```

**Example : Conta il numero di volte in cui una richiesta proveniente da un Paese specificato è stata bloccata**  
La seguente query conteggia il numero di volte in cui la richiesta è arrivata da un indirizzo IP che appartiene all'Irlanda (IE) ed è stato bloccato dalla regola di terminazione `RATE_BASED`.  

```
SELECT 
  COUNT(httpRequest.country) as count, 
  httpRequest.country 
FROM waf_logs
WHERE 
  terminatingruletype='RATE_BASED' AND 
  httpRequest.country='IE'
GROUP BY httpRequest.country
ORDER BY count
LIMIT 100;
```

**Example : Conta il numero di volte in cui una richiesta è stata bloccata, raggruppando per attributi specifici**  
La seguente query conta il numero di volte in cui la richiesta è stata bloccata, con risultati raggruppati per WebACL RuleId, ClientIP e URI di richiesta HTTP.  

```
SELECT 
  COUNT(*) AS count,
  webaclid,
  terminatingruleid,
  httprequest.clientip,
  httprequest.uri
FROM waf_logs
WHERE action='BLOCK'
GROUP BY webaclid, terminatingruleid, httprequest.clientip, httprequest.uri
ORDER BY count DESC
LIMIT 100;
```

**Example : Conta il numero di volte in cui è stata trovata una corrispondenza con un determinato ID di regola di terminazione**  
La seguente query conteggia il numero di volte in cui un determinato ID regola di terminazione è stato corrisposto (`WHERE terminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'`). La query raggrupperà i risultati per WebACL, Operazione, ClientIP e URI della richiesta HTTP.  

```
SELECT 
  COUNT(*) AS count,
  webaclid,
  action,
  httprequest.clientip,
  httprequest.uri
FROM waf_logs
WHERE terminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'
GROUP BY webaclid, action, httprequest.clientip, httprequest.uri
ORDER BY count DESC
LIMIT 100;
```

**Example : Recupera i primi 100 indirizzi IP bloccati durante un intervallo di date specificato**  
Nella query seguente vengono estratti i primi 100 indirizzi IP bloccati per un intervallo di date specificato. La query elenca anche il numero di volte in cui gli indirizzi IP sono stati bloccati.  

```
SELECT "httprequest"."clientip", "count"(*) "ipcount", "httprequest"."country"
FROM waf_logs
WHERE "action" = 'BLOCK' and "date" >= '2021/03/01'
AND "date" < '2021/03/31'
GROUP BY "httprequest"."clientip", "httprequest"."country"
ORDER BY "ipcount" DESC limit 100
```