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

# Servizio AWS Registri delle interrogazioni
<a name="querying-aws-service-logs"></a>

Questa sezione include diverse procedure per utilizzare Amazon Athena per interrogare i set di dati più diffusi, come AWS CloudTrail log, log CloudFront Amazon, log Classic Load Balancer, log Application Load Balancer, log di flusso Amazon VPC e log Network Load Balancer.

Per le attività riportate in questa sezione viene impiegata la console Athena, tuttavia puoi usare anche altri strumenti come il [driver JDBC Athena](connect-with-jdbc.md), la [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/athena/) o la [documentazione di riferimento all'API Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/).

Per informazioni sull'utilizzo per AWS CloudFormation creare automaticamente tabelle di Servizio AWS log, partizioni e query di esempio in Athena, consulta [Automatizzare la creazione di tabelle di Servizio AWS log e interrogarle con Amazon Athena](https://aws.amazon.com/blogs/big-data/automating-aws-service-logs-table-creation-and-querying-them-with-amazon-athena/) nel Big Data Blog. AWS Per informazioni sull'utilizzo di una libreria Python per creare un framework comune AWS Glue per l'elaborazione dei Servizio AWS log e la loro interrogazione in Athena, consulta Easly query [logs](https://aws.amazon.com/blogs/big-data/easily-query-aws-service-logs-using-amazon-athena/) using Amazon Athena. Servizio AWS 

Gli argomenti di questa sezione presuppongono che tu abbia configurato le autorizzazioni adeguate per accedere ad Athena e al bucket Amazon S3 in cui devono risiedere i dati su cui eseguire la query. Per ulteriori informazioni, consultare [Configurare l’accesso amministrativo e programmatico](setting-up.md) e [Nozioni di base](getting-started.md).

**Topics**
+ [Application Load Balancer](application-load-balancer-logs.md)
+ [Elastic Load Balancing](elasticloadbalancer-classic-logs.md)
+ [CloudFront](cloudfront-logs.md)
+ [CloudTrail](cloudtrail-logs.md)
+ [Amazon EMR](emr-logs.md)
+ [Global Accelerator](querying-global-accelerator-flow-logs.md)
+ [GuardDuty](querying-guardduty.md)
+ [Network Firewall](querying-network-firewall-logs.md)
+ [Network Load Balancer](networkloadbalancer-classic-logs.md)
+ [Route 53](querying-r53-resolver-logs.md)
+ [Amazon SES](querying-ses-logs.md)
+ [Amazon VPC](vpc-flow-logs.md)
+ [AWS WAF](waf-logs.md)

# Eseguire query nei log di Application Load Balancer
<a name="application-load-balancer-logs"></a>

Un Application Load Balancer è un'opzione di bilanciamento del carico in Elastic Load Balancing che consente di smistare il traffico in una distribuzione a microservizi con container. Eseguire query sui log dell'Application Load Balancer consente di individuare l'origine del traffico, la latenza e i byte trasferiti a e da istanze Elastic Load Balancing e applicazioni di back-end. Per ulteriori informazioni, consultare [Log di accesso per l’Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html) e [Log di connessione per Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html) nella *Guida per l’utente di Application Load Balancer*.

## Prerequisiti
<a name="application-load-balancer-logs-prerequisites"></a>
+ Abilita i [log di accesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html) o i [log di connessione ](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html) in modo che i log di Application Load Balancer possano essere salvati nel bucket Amazon S3.
+ Un database per mantenere la tabella da creare per Athena. Per creare un database, puoi usare Athena o AWS Glue la console. Per ulteriori informazioni, consulta [Creare database in Athena](creating-databases.md) in questa guida o [Lavorare con i database nella console AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-databases.html) nella *Guida per gli sviluppatori di AWS Glue *. 

**Topics**
+ [Prerequisiti](#application-load-balancer-logs-prerequisites)
+ [Creazione della tabella per l’accesso ALB ai log](create-alb-access-logs-table.md)
+ [Creazione della tabella per i log di accesso ALB in Athena utilizzando la proiezione delle partizioni](create-alb-access-logs-table-partition-projection.md)
+ [Esempio di query per i log di accesso di ALB](query-alb-access-logs-examples.md)
+ [Creare la tabella per i log di connessione ALB](create-alb-connection-logs-table.md)
+ [Creazione della tabella per i log di connessione ALB in Athena utilizzando la proiezione delle partizioni](create-alb-connection-logs-table-partition-projection.md)
+ [Esempio di query per i log di connessione ALB](query-alb-connection-logs-examples.md)
+ [Risorse aggiuntive](application-load-balancer-logs-additional-resources.md)

# Creazione della tabella per l’accesso ALB ai log
<a name="create-alb-access-logs-table"></a>

1. Copiare e incollare la seguente dichiarazione `CREATE TABLE` nell’editor di query della console Athena, quindi modificarla se necessario in base alle esigenze di immissione dei log. Per informazioni sull'utilizzo della console Athena, consulta [Nozioni di base](getting-started.md). Sostituire il percorso nella clausola `LOCATION` con la propria posizione della cartella del log di accesso di Amazon S3. Per ulteriori informazioni sulla posizione da cui accedere al file del log, consultare [Accedere a file di log](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-file-format) nella *Guida per l’utente di Application Load Balancer*.

   Per ulteriori informazioni su ciascun campo, consultare [Voci del log di accesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-entry-format) nella *Guida per l’utente per Application Load Balancer*.
**Nota**  
L’istruzione di esempio seguente `CREATE TABLE` include le colonne `classification`, `classification_reason` e `conn_trace_id` (’ID tracciabilità’ o TID). Per creare una tabella per i log di accesso di Application Load Balancer che non contengono queste voci, rimuovere le due colonne corrispondenti dall’istruzione `CREATE TABLE` e modificare l’espressione regolare di conseguenza. 

   ```
   CREATE EXTERNAL TABLE IF NOT EXISTS alb_access_logs (
               type string,
               time string,
               elb string,
               client_ip string,
               client_port int,
               target_ip string,
               target_port int,
               request_processing_time double,
               target_processing_time double,
               response_processing_time double,
               elb_status_code int,
               target_status_code string,
               received_bytes bigint,
               sent_bytes bigint,
               request_verb string,
               request_url string,
               request_proto string,
               user_agent string,
               ssl_cipher string,
               ssl_protocol string,
               target_group_arn string,
               trace_id string,
               domain_name string,
               chosen_cert_arn string,
               matched_rule_priority string,
               request_creation_time string,
               actions_executed string,
               redirect_url string,
               lambda_error_reason string,
               target_port_list string,
               target_status_code_list string,
               classification string,
               classification_reason string,
               conn_trace_id string
               )
               ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
               WITH SERDEPROPERTIES (
               'serialization.format' = '1',
               'input.regex' = 
           '([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*)[:-]([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-.0-9]*) (|[-0-9]*) (-|[-0-9]*) ([-0-9]*) ([-0-9]*) \"([^ ]*) (.*) (- |[^ ]*)\" \"([^\"]*)\" ([A-Z0-9-_]+) ([A-Za-z0-9.-]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\" \"([^\"]*)\" ([-.0-9]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\" \"([^ ]*)\" \"([^\\s]+?)\" \"([^\\s]+)\" \"([^ ]*)\" \"([^ ]*)\" ?([^ ]*)? ?( .*)?'
               )
               LOCATION 's3://amzn-s3-demo-bucket/access-log-folder-path/'
   ```
**Nota**  
Suggeriamo che lo schema *`?( .*)?`* alla fine del parametro `input.regex` rimanga sempre invariato per gestire le future voci del log nel caso in cui vengano aggiunti nuovi campi di log ALB. 

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `alb_access_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.

# Creazione della tabella per i log di accesso ALB in Athena utilizzando la proiezione delle partizioni
<a name="create-alb-access-logs-table-partition-projection"></a>

Poiché i log ALB dispongono di una struttura nota il cui schema di partizione può essere specificato in anticipo, è possibile ridurre il runtime delle query e automatizzare la gestione delle partizioni utilizzando la funzionalità di proiezione delle partizioni di Athena. 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’esempio di istruzione seguente `CREATE TABLE` utilizza automaticamente la proiezione delle partizioni nei log ALB da una data specificata fino alla presente per una singola regione AWS . L'istruzione si basa sull'esempio della sezione precedente, ma aggiunge le clausole `PARTITIONED BY` e `TBLPROPERTIES` per abilitare la proiezione delle partizioni. Nelle clausole `LOCATION` e `storage.location.template`, sostituire i segnaposto con valori che identificano la posizione del bucket Amazon S3 dei propri log di accesso ALB. Per maggiori informazioni sulla posizione del file del log di accesso consultare [File del log di accesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-file-format) nella *Guida utente per Application Load Balancers*. Per`projection.day.range`, sostituisci *2022**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. Per informazioni su ogni campo del file di registro, vedere [Elenco log di accesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-entry-format). 

```
CREATE EXTERNAL TABLE IF NOT EXISTS alb_access_logs (
            type string,
            time string,
            elb string,
            client_ip string,
            client_port int,
            target_ip string,
            target_port int,
            request_processing_time double,
            target_processing_time double,
            response_processing_time double,
            elb_status_code int,
            target_status_code string,
            received_bytes bigint,
            sent_bytes bigint,
            request_verb string,
            request_url string,
            request_proto string,
            user_agent string,
            ssl_cipher string,
            ssl_protocol string,
            target_group_arn string,
            trace_id string,
            domain_name string,
            chosen_cert_arn string,
            matched_rule_priority string,
            request_creation_time string,
            actions_executed string,
            redirect_url string,
            lambda_error_reason string,
            target_port_list string,
            target_status_code_list string,
            classification string,
            classification_reason string,
            conn_trace_id string
            )
            PARTITIONED BY
            (
             day STRING
            )
            ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
            WITH SERDEPROPERTIES (
            'serialization.format' = '1',
            'input.regex' = 
        '([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*)[:-]([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-.0-9]*) (|[-0-9]*) (-|[-0-9]*) ([-0-9]*) ([-0-9]*) \"([^ ]*) (.*) (- |[^ ]*)\" \"([^\"]*)\" ([A-Z0-9-_]+) ([A-Za-z0-9.-]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\" \"([^\"]*)\" ([-.0-9]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\" \"([^ ]*)\" \"([^\\s]+?)\" \"([^\\s]+)\" \"([^ ]*)\" \"([^ ]*)\" ?([^ ]*)? ?( .*)?'
            )
            LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/<ACCOUNT-NUMBER>/elasticloadbalancing/<REGION>/'
            TBLPROPERTIES
            (
             "projection.enabled" = "true",
             "projection.day.type" = "date",
             "projection.day.range" = "2022/01/01,NOW",
             "projection.day.format" = "yyyy/MM/dd",
             "projection.day.interval" = "1",
             "projection.day.interval.unit" = "DAYS",
             "storage.location.template" = "s3://amzn-s3-demo-bucket/AWSLogs/<ACCOUNT-NUMBER>/elasticloadbalancing/<REGION>/${day}"
            )
```

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

**Nota**  
Suggeriamo che lo schema *?( .\$1)?* alla fine del parametro `input.regex` rimanga sempre invariato per gestire le future voci del log nel caso in cui vengano aggiunti nuovi campi di log ALB. 

# Esempio di query per i log di accesso di ALB
<a name="query-alb-access-logs-examples"></a>

La seguente query conteggia il numero di richieste HTTP GET ricevute dal load balancer, raggruppate in base all'indirizzo IP del client:

```
SELECT COUNT(request_verb) AS
 count,
 request_verb,
 client_ip
FROM alb_access_logs
GROUP BY request_verb, client_ip
LIMIT 100;
```

Un'altra query mostra i siti URLs visitati dagli utenti del browser Safari:

```
SELECT request_url
FROM alb_access_logs
WHERE user_agent LIKE '%Safari%'
LIMIT 10;
```

La seguente query mostra i record con valori del codice di stato ELB maggiori o uguali a 500.

```
SELECT * FROM alb_access_logs
WHERE elb_status_code >= 500
```

Il seguente esempio illustra come analizzare i log per `datetime`:

```
SELECT client_ip, sum(received_bytes) 
FROM alb_access_logs
WHERE parse_datetime(time,'yyyy-MM-dd''T''HH:mm:ss.SSSSSS''Z') 
     BETWEEN parse_datetime('2018-05-30-12:00:00','yyyy-MM-dd-HH:mm:ss') 
     AND parse_datetime('2018-05-31-00:00:00','yyyy-MM-dd-HH:mm:ss') 
GROUP BY client_ip;
```

La query seguente esegue una query sulla tabella che utilizza la proiezione delle partizioni per tutti i log di accesso ALB dal giorno specificato.

```
SELECT * 
FROM alb_access_logs 
WHERE day = '2022/02/12'
```

# Creare la tabella per i log di connessione ALB
<a name="create-alb-connection-logs-table"></a>

1. Copiare e incollare l’istruzione `CREATE TABLE` del seguente esempio nell’editor di query della console Athena, quindi modificala se necessario per i requisiti di immissione del proprio log. Per informazioni sull'utilizzo della console Athena, consulta [Nozioni di base](getting-started.md). Sostituisci il percorso nella clausola `LOCATION` con la posizione della cartella del log di connessione Amazon S3. Per ulteriori informazioni sulla posizione dei file di log delle connessioni, consultare [File di log delle connessioni](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-file-format) nella *Guida utente per Application Load Balancer*. Per informazioni su ogni campo del file di log, vedere [Immissioni log di connessione](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-entry-format). 

   ```
   CREATE EXTERNAL TABLE IF NOT EXISTS alb_connection_logs (
            time string,
            client_ip string,
            client_port int,
            listener_port int,
            tls_protocol string,
            tls_cipher string,
            tls_handshake_latency double,
            leaf_client_cert_subject string,
            leaf_client_cert_validity string,
            leaf_client_cert_serial_number string,
            tls_verify_status string,
            conn_trace_id string
            ) 
            ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
            WITH SERDEPROPERTIES (
            'serialization.format' = '1',
            'input.regex' =
             '([^ ]*) ([^ ]*) ([0-9]*) ([0-9]*) ([A-Za-z0-9.-]*) ([^ ]*) ([-.0-9]*) \"([^\"]*)\" ([^ ]*) ([^ ]*) ([^ ]*) ?([^ ]*)?( .*)?'
            )
            LOCATION 's3://amzn-s3-demo-bucket/connection-log-folder-path/'
   ```

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `alb_connection_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.

# Creazione della tabella per i log di connessione ALB in Athena utilizzando la proiezione delle partizioni
<a name="create-alb-connection-logs-table-partition-projection"></a>

Poiché i log di connessione ALB dispongono di una struttura nota il cui schema di partizione può essere specificato in anticipo, è possibile ridurre il runtime delle query e automatizzare la gestione delle partizioni utilizzando la funzionalità di proiezione delle partizioni di Athena. 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’esempio di istruzione seguente `CREATE TABLE` utilizza automaticamente la proiezione delle partizioni nei log di connessione ALB da una data specificata fino alla presente per una singola regione AWS . L'istruzione si basa sull'esempio della sezione precedente, ma aggiunge le clausole `PARTITIONED BY` e `TBLPROPERTIES` per abilitare la proiezione delle partizioni. Nelle clausole `LOCATION` e `storage.location.template`, sostituire i segnaposto con valori che identificano la posizione del bucket Amazon S3 dei propri log di connessione ALB. Per ulteriori informazioni sulla posizione dei file di log delle connessioni, vedere [File di log delle connessioni](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-file-format) nella *Guida dell’utente per Application Load Balancer*. Per`projection.day.range`, sostituisci *2023**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. Per informazioni su ogni campo del file di vedere, vedere [Immissioni log di connessione](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-entry-format).

```
CREATE EXTERNAL TABLE IF NOT EXISTS alb_connection_logs (
         time string,
         client_ip string,
         client_port int,
         listener_port int,
         tls_protocol string,
         tls_cipher string,
         tls_handshake_latency double,
         leaf_client_cert_subject string,
         leaf_client_cert_validity string,
         leaf_client_cert_serial_number string,
         tls_verify_status string,
         conn_trace_id string
         )
            PARTITIONED BY
            (
             day STRING
            )
            ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
            WITH SERDEPROPERTIES (
            'serialization.format' = '1',
            'input.regex' =
             '([^ ]*) ([^ ]*) ([0-9]*) ([0-9]*) ([A-Za-z0-9.-]*) ([^ ]*) ([-.0-9]*) \"([^\"]*)\" ([^ ]*) ([^ ]*) ([^ ]*) ?([^ ]*)?( .*)?'
            )
            LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/<ACCOUNT-NUMBER>/elasticloadbalancing/<REGION>/'
            TBLPROPERTIES
            (
             "projection.enabled" = "true",
             "projection.day.type" = "date",
             "projection.day.range" = "2023/01/01,NOW",
             "projection.day.format" = "yyyy/MM/dd",
             "projection.day.interval" = "1",
             "projection.day.interval.unit" = "DAYS",
             "storage.location.template" = "s3://amzn-s3-demo-bucket/AWSLogs/<ACCOUNT-NUMBER>/elasticloadbalancing/<REGION>/${day}"
            )
```

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

# Esempio di query per i log di connessione ALB
<a name="query-alb-connection-logs-examples"></a>

Le seguenti query contano le occorrenze in cui il valore per `tls_verify_status` non era `'Success'`, raggruppate per indirizzo IP del client:

```
SELECT DISTINCT client_ip, count() AS count FROM alb_connection_logs
WHERE tls_verify_status != 'Success'
GROUP BY client_ip
ORDER BY count() DESC;
```

La seguente query cerca le occorrenze in cui il valore per `tls_handshake_latency` è superiore a 2 secondi nell’intervallo di tempo specificato:

```
SELECT * FROM alb_connection_logs
WHERE 
  (
    parse_datetime(time, 'yyyy-MM-dd''T''HH:mm:ss.SSSSSS''Z') 
    BETWEEN 
    parse_datetime('2024-01-01-00:00:00', 'yyyy-MM-dd-HH:mm:ss') 
    AND 
    parse_datetime('2024-03-20-00:00:00', 'yyyy-MM-dd-HH:mm:ss') 
  ) 
  AND 
    (tls_handshake_latency >= 2.0);
```

# Risorse aggiuntive
<a name="application-load-balancer-logs-additional-resources"></a>

Per ulteriori informazioni sull’utilizzo dei log ALB, consultare le seguenti risorse.
+ [Come posso analizzare i log di accesso di Application Load Balancer utilizzando Amazon Athena?](https://repost.aws/knowledge-center/athena-analyze-access-logs) nel *Centro conoscenze di AWS *.
+ Per informazioni sui codici di stato HTTP in Elastic Load Balancing, consulta [Risoluzione dei problemi con Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-troubleshooting.html) nella *Guida per l'utente di Application Load Balancer*.
+ [Cataloga e analizza i log di Application Load Balancer in modo più efficiente con classificatori AWS Glue personalizzati e Amazon Athena](https://aws.amazon.com/blogs/big-data/catalog-and-analyze-application-load-balancer-logs-more-efficiently-with-aws-glue-custom-classifiers-and-amazon-athena/) *nel Big Data Blog.AWS *

# Eseguire query su log Classic Load Balancer
<a name="elasticloadbalancer-classic-logs"></a>

Usa i log di Classic Load Balancer per analizzare e comprendere i modelli di traffico da e verso le istanze di Elastic Load Balancing e le applicazioni di back-end. È possibile visualizzare sorgente di traffico, latenza e byte trasferiti.

Prima di analizzare i log di Elastic Load Balancing, configurali affinché siano salvati nel bucket Amazon S3 di destinazione. Per ulteriori informazioni, consulta la sezione relativa all'[accesso ai log di Classic Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-access-logs.html).

**Per creare la tabella per i log di Elastic Load Balancing**

1. Copiare e incollare la seguente istruzione DDL nella console Athena. Controlla la [sintassi ](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/access-log-collection.html#access-log-entry-format)dei record di log di Elastic Load Balancing. Potrebbe essere necessario aggiornare la seguente query per includere le colonne e la sintassi Regex per la versione più recente del record. 

   ```
   CREATE EXTERNAL TABLE IF NOT EXISTS elb_logs (
    
    timestamp string,
    elb_name string,
    request_ip string,
    request_port int,
    backend_ip string,
    backend_port int,
    request_processing_time double,
    backend_processing_time double,
    client_response_time double,
    elb_response_code string,
    backend_response_code string,
    received_bytes bigint,
    sent_bytes bigint,
    request_verb string,
    url string,
    protocol string,
    user_agent string,
    ssl_cipher string,
    ssl_protocol string
   )
   ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
   WITH SERDEPROPERTIES (
    'serialization.format' = '1',
    'input.regex' = '([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*)[:-]([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-.0-9]*) (|[-0-9]*) (-|[-0-9]*) ([-0-9]*) ([-0-9]*) \\\"([^ ]*) ([^ ]*) (- |[^ ]*)\\\" (\"[^\"]*\") ([A-Z0-9-]+) ([A-Za-z0-9.-]*)$'
   )
   LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/AWS_account_ID/elasticloadbalancing/';
   ```

1. Modifica il bucket Amazon S3 `LOCATION` per specificare la destinazione dei tuoi log di Elastic Load Balancing.

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `elb_logs`, rendendo i dati in essa contenuti pronti per le query. Per ulteriori informazioni, consulta [Query di esempio](#query-elb-classic-example).

## Query di esempio
<a name="query-elb-classic-example"></a>

Eseguire una query simile all'esempio seguente. In tale query sono elencati i server di applicazioni di back-end che hanno restituito un codice di risposta di errore `4XX` o `5XX`. Utilizza l'operatore `LIMIT` per limitare il numero di log di cui eseguire la query alla volta.

```
SELECT
 timestamp,
 elb_name,
 backend_ip,
 backend_response_code
FROM elb_logs
WHERE backend_response_code LIKE '4%' OR
      backend_response_code LIKE '5%'
LIMIT 100;
```

Utilizza una successiva query per sommare il tempo di risposta di tutte le transazioni raggruppate in base all'indirizzo IP del back-end e al nome dell'istanza Elastic Load Balancing.

```
SELECT sum(backend_processing_time) AS
 total_ms,
 elb_name,
 backend_ip
FROM elb_logs WHERE backend_ip <> ''
GROUP BY backend_ip, elb_name
LIMIT 100;
```

Per ulteriori informazioni, consulta la sezione relativa all'[analisi dei dati su S3 utilizzando Athena](https://aws.amazon.com/blogs/big-data/analyzing-data-in-s3-using-amazon-athena/).

# Interroga i CloudFront log di Amazon
<a name="cloudfront-logs"></a>

Puoi configurare Amazon CloudFront CDN per esportare i log di accesso alla distribuzione Web su Amazon Simple Storage Service. Usa questi log per esplorare i modelli di navigazione degli utenti tra le proprietà web servite da. CloudFront

Prima di iniziare a eseguire query sui log, abilita i log di accesso per le distribuzioni Web sulla tua distribuzione CloudFront preferita. Per informazioni, consulta [i log di accesso](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html) nella *Amazon CloudFront Developer Guide*. Prendi nota del bucket Amazon S3 in cui salvi questi log.

**Topics**
+ [Crea una tabella per i log CloudFront standard (legacy)](create-cloudfront-table-standard-logs.md)
+ [Crea una tabella per CloudFront i log in Athena utilizzando il partizionamento manuale con JSON](create-cloudfront-table-manual-json.md)
+ [Crea una tabella per CloudFront i registri in Athena utilizzando il partizionamento manuale con Parquet](create-cloudfront-table-manual-parquet.md)
+ [Crea una tabella per CloudFront i log in Athena utilizzando la proiezione delle partizioni con JSON](create-cloudfront-table-partition-json.md)
+ [Crea una tabella per CloudFront i registri in Athena utilizzando la proiezione delle partizioni con Parquet](create-cloudfront-table-partition-parquet.md)
+ [Crea una tabella per i log in tempo reale CloudFront](create-cloudfront-table-real-time-logs.md)
+ [Risorse aggiuntive](cloudfront-logs-additional-resources.md)

# Crea una tabella per i log CloudFront standard (legacy)
<a name="create-cloudfront-table-standard-logs"></a>

**Nota**  
La procedura seguente funziona per i log di accesso alla distribuzione Web. CloudFront Non si applica ai log di streaming delle distribuzioni RTMP.

**Per creare una tabella per i campi CloudFront standard dei file di log**

1. Copia e incolla la seguente istruzione DDL di esempio nell'Editor di query della console Athena. L'istruzione di esempio utilizza i campi del file di registro documentati nella sezione [Campi dei file di log standard](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) della *Amazon CloudFront Developer Guide*. Modifica il parametro `LOCATION` per il bucket Amazon S3 in cui sono archiviati i log. Per ulteriori informazioni sull'utilizzo dell'editor di query, consulta [Nozioni di base](getting-started.md).

   Questa query specifica `ROW FORMAT DELIMITED` e `FIELDS TERMINATED BY '\t'` per indicare che i campi sono delimitati da caratteri di tabulazione. Per`ROW FORMAT DELIMITED`, Athena utilizza per impostazione [LazySimpleSerDe](lazy-simple-serde.md)predefinita. Nella colonna `date` viene inserito il carattere escape con l'apice inverso (`) perché è una parola riservata in Athena. Per informazioni, consulta [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md).

   ```
   CREATE EXTERNAL TABLE IF NOT EXISTS cloudfront_standard_logs (
     `date` DATE,
     time STRING,
     x_edge_location STRING,
     sc_bytes BIGINT,
     c_ip STRING,
     cs_method STRING,
     cs_host STRING,
     cs_uri_stem STRING,
     sc_status INT,
     cs_referrer STRING,
     cs_user_agent STRING,
     cs_uri_query STRING,
     cs_cookie STRING,
     x_edge_result_type STRING,
     x_edge_request_id STRING,
     x_host_header STRING,
     cs_protocol STRING,
     cs_bytes BIGINT,
     time_taken FLOAT,
     x_forwarded_for STRING,
     ssl_protocol STRING,
     ssl_cipher STRING,
     x_edge_response_result_type STRING,
     cs_protocol_version STRING,
     fle_status STRING,
     fle_encrypted_fields INT,
     c_port INT,
     time_to_first_byte FLOAT,
     x_edge_detailed_result_type STRING,
     sc_content_type STRING,
     sc_content_len BIGINT,
     sc_range_start BIGINT,
     sc_range_end BIGINT
   )
   ROW FORMAT DELIMITED 
   FIELDS TERMINATED BY '\t'
   LOCATION 's3://amzn-s3-demo-bucket/'
   TBLPROPERTIES ( 'skip.header.line.count'='2' )
   ```

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `cloudfront_standard_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.

## Query di esempio
<a name="query-examples-cloudfront-logs"></a>

La seguente query somma il numero di byte serviti CloudFront tra il 9 giugno e l'11 giugno 2018. Racchiudi fra virgolette doppie il nome della colonna della data perché è una parola riservata.

```
SELECT SUM(bytes) AS total_bytes
FROM cloudfront_standard_logs
WHERE "date" BETWEEN DATE '2018-06-09' AND DATE '2018-06-11'
LIMIT 100;
```

Per eliminare righe duplicate (ad esempio, righe vuote duplicate) dai risultati della query, è possibile utilizzare l'istruzione `SELECT DISTINCT`, come nell'esempio seguente. 

```
SELECT DISTINCT * 
FROM cloudfront_standard_logs 
LIMIT 10;
```

# Crea una tabella per CloudFront i log in Athena utilizzando il partizionamento manuale con JSON
<a name="create-cloudfront-table-manual-json"></a>

**Per creare una tabella per i campi CloudFront standard dei file di log utilizzando un formato JSON**

1. Copia e incolla la seguente istruzione DDL di esempio nell'Editor di query della console Athena. L'istruzione di esempio utilizza i campi del file di registro documentati nella sezione [Campi dei file di log standard](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) della *Amazon CloudFront Developer Guide*. Modifica il parametro `LOCATION` per il bucket Amazon S3 in cui sono archiviati i log. 

   Questa query utilizza OpenX JSON SerDe con le seguenti SerDe proprietà per leggere correttamente i campi JSON in Athena.

   ```
   CREATE EXTERNAL TABLE `cf_logs_manual_partition_json`(
     `date` string , 
     `time` string , 
     `x-edge-location` string , 
     `sc-bytes` string , 
     `c-ip` string , 
     `cs-method` string , 
     `cs(host)` string , 
     `cs-uri-stem` string , 
     `sc-status` string , 
     `cs(referer)` string , 
     `cs(user-agent)` string , 
     `cs-uri-query` string , 
     `cs(cookie)` string , 
     `x-edge-result-type` string , 
     `x-edge-request-id` string , 
     `x-host-header` string , 
     `cs-protocol` string , 
     `cs-bytes` string , 
     `time-taken` string , 
     `x-forwarded-for` string , 
     `ssl-protocol` string , 
     `ssl-cipher` string , 
     `x-edge-response-result-type` string , 
     `cs-protocol-version` string , 
     `fle-status` string , 
     `fle-encrypted-fields` string , 
     `c-port` string , 
     `time-to-first-byte` string , 
     `x-edge-detailed-result-type` string , 
     `sc-content-type` string , 
     `sc-content-len` string , 
     `sc-range-start` string , 
     `sc-range-end` string )
   ROW FORMAT SERDE 
     'org.openx.data.jsonserde.JsonSerDe' 
   WITH SERDEPROPERTIES ( 
     'paths'='c-ip,c-port,cs(Cookie),cs(Host),cs(Referer),cs(User-Agent),cs-bytes,cs-method,cs-protocol,cs-protocol-version,cs-uri-query,cs-uri-stem,date,fle-encrypted-fields,fle-status,sc-bytes,sc-content-len,sc-content-type,sc-range-end,sc-range-start,sc-status,ssl-cipher,ssl-protocol,time,time-taken,time-to-first-byte,x-edge-detailed-result-type,x-edge-location,x-edge-request-id,x-edge-response-result-type,x-edge-result-type,x-forwarded-for,x-host-header') 
   STORED AS INPUTFORMAT 
     'org.apache.hadoop.mapred.TextInputFormat' 
   OUTPUTFORMAT 
     'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
   LOCATION
     's3://amzn-s3-demo-bucket/'
   ```

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `cf_logs_manual_partition_json`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.

## Query di esempio
<a name="query-examples-cloudfront-logs-manual-json"></a>

La seguente query somma il numero di byte serviti CloudFront per il 15 gennaio 2025.

```
SELECT sum(cast("sc-bytes" as BIGINT)) as sc
FROM cf_logs_manual_partition_json
WHERE "date"='2025-01-15'
```

Per eliminare righe duplicate (ad esempio, righe vuote duplicate) dai risultati della query, è possibile utilizzare l'istruzione `SELECT DISTINCT`, come nell'esempio seguente. 

```
SELECT DISTINCT * FROM cf_logs_manual_partition_json
```

# Crea una tabella per CloudFront i registri in Athena utilizzando il partizionamento manuale con Parquet
<a name="create-cloudfront-table-manual-parquet"></a>

**Per creare una tabella per i campi CloudFront standard dei file di log utilizzando un formato Parquet**

1. Copia e incolla la seguente istruzione DDL di esempio nell'Editor di query della console Athena. L'istruzione di esempio utilizza i campi del file di registro documentati nella sezione [Campi dei file di log standard](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) della *Amazon CloudFront Developer Guide*. 

   Questa query utilizza ParquetHiveSerDe le seguenti SerDe proprietà per leggere correttamente i campi Parquet in Athena.

   ```
   CREATE EXTERNAL TABLE `cf_logs_manual_partition_parquet`(
     `date` string, 
     `time` string, 
     `x_edge_location` string, 
     `sc_bytes` string, 
     `c_ip` string, 
     `cs_method` string, 
     `cs_host` string, 
     `cs_uri_stem` string, 
     `sc_status` string, 
     `cs_referer` string, 
     `cs_user_agent` string, 
     `cs_uri_query` string, 
     `cs_cookie` string, 
     `x_edge_result_type` string, 
     `x_edge_request_id` string, 
     `x_host_header` string, 
     `cs_protocol` string, 
     `cs_bytes` string, 
     `time_taken` string, 
     `x_forwarded_for` string, 
     `ssl_protocol` string, 
     `ssl_cipher` string, 
     `x_edge_response_result_type` string, 
     `cs_protocol_version` string, 
     `fle_status` string, 
     `fle_encrypted_fields` string, 
     `c_port` string, 
     `time_to_first_byte` string, 
     `x_edge_detailed_result_type` string, 
     `sc_content_type` string, 
     `sc_content_len` string, 
     `sc_range_start` string, 
     `sc_range_end` string)
   ROW FORMAT SERDE 
     'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe' 
   STORED AS INPUTFORMAT 
     'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat' 
   OUTPUTFORMAT 
     'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
   LOCATION
     's3://amzn-s3-demo-bucket/'
   ```

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `cf_logs_manual_partition_parquet`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.

## Query di esempio
<a name="query-examples-cloudfront-logs-manual-parquet"></a>

La seguente query somma il numero di byte serviti CloudFront per il 19 gennaio 2025.

```
SELECT sum(cast("sc_bytes" as BIGINT)) as sc
FROM cf_logs_manual_partition_parquet
WHERE "date"='2025-01-19'
```

Per eliminare righe duplicate (ad esempio, righe vuote duplicate) dai risultati della query, è possibile utilizzare l'istruzione `SELECT DISTINCT`, come nell'esempio seguente. 

```
SELECT DISTINCT * FROM cf_logs_manual_partition_parquet
```

# Crea una tabella per CloudFront i log in Athena utilizzando la proiezione delle partizioni con JSON
<a name="create-cloudfront-table-partition-json"></a>

È possibile ridurre il tempo di runtime delle query e automatizzare la gestione delle partizioni con la funzionalità di proiezione delle partizioni Athena. 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'esempio seguente, l'istruzione CREATE TABLE utilizza automaticamente la proiezione delle partizioni sui CloudFront log di una distribuzione specificata fino a quando non sono presenti per una singola distribuzione. CloudFront Regione AWS Dopo aver eseguito la query con esito positivo, è possibile eseguire query sulla tabella.

```
CREATE EXTERNAL TABLE `cloudfront_logs_pp`(
  `date` string, 
  `time` string, 
  `x-edge-location` string, 
  `sc-bytes` string, 
  `c-ip` string, 
  `cs-method` string, 
  `cs(host)` string, 
  `cs-uri-stem` string, 
  `sc-status` string, 
  `cs(referer)` string, 
  `cs(user-agent)` string, 
  `cs-uri-query` string, 
  `cs(cookie)` string, 
  `x-edge-result-type` string, 
  `x-edge-request-id` string, 
  `x-host-header` string, 
  `cs-protocol` string, 
  `cs-bytes` string, 
  `time-taken` string, 
  `x-forwarded-for` string, 
  `ssl-protocol` string, 
  `ssl-cipher` string, 
  `x-edge-response-result-type` string, 
  `cs-protocol-version` string, 
  `fle-status` string, 
  `fle-encrypted-fields` string, 
  `c-port` string, 
  `time-to-first-byte` string, 
  `x-edge-detailed-result-type` string, 
  `sc-content-type` string, 
  `sc-content-len` string, 
  `sc-range-start` string, 
  `sc-range-end` string)
  PARTITIONED BY(
         distributionid string,
         year int,
         month int,
         day int,
         hour int )
ROW FORMAT SERDE 
  'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ( 
  'paths'='c-ip,c-port,cs(Cookie),cs(Host),cs(Referer),cs(User-Agent),cs-bytes,cs-method,cs-protocol,cs-protocol-version,cs-uri-query,cs-uri-stem,date,fle-encrypted-fields,fle-status,sc-bytes,sc-content-len,sc-content-type,sc-range-end,sc-range-start,sc-status,ssl-cipher,ssl-protocol,time,time-taken,time-to-first-byte,x-edge-detailed-result-type,x-edge-location,x-edge-request-id,x-edge-response-result-type,x-edge-result-type,x-forwarded-for,x-host-header') 
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_ID/CloudFront/'
TBLPROPERTIES (
  'projection.distributionid.type'='enum',
  'projection.distributionid.values'='E2Oxxxxxxxxxxx',
  'projection.day.range'='01,31', 
  'projection.day.type'='integer', 
  'projection.day.digits'='2', 
  'projection.enabled'='true', 
  'projection.month.range'='01,12', 
  'projection.month.type'='integer', 
  'projection.month.digits'='2', 
  'projection.year.range'='2025,2026', 
  'projection.year.type'='integer', 
  'projection.hour.range'='00,23',
  'projection.hour.type'='integer',
  'projection.hour.digits'='2',
  'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/CloudFront/${distributionid}/${year}/${month}/${day}/${hour}/')
```

Di seguito sono riportate alcune considerazioni sulle proprietà utilizzate nell’esempio precedente.
+ **Nome tabella**: il nome della tabella *`cloudfront_logs_pp`* è sostituibile. È possibile cambiarlo con il nome che si desidera.
+ **Posizione**: modificare `s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/` in modo che punti al proprio bucket Amazon S3.
+ **Distribuzione IDs**: per`projection.distributionid.values`, è possibile specificare più distribuzioni IDs se le si separano con virgole. Ad esempio, *<distributionID1>*, *<distributionID2>*.
+ **Intervallo di anni**: nel `projection.year.range`, è possibile definire l’intervallo di anni in base ai propri dati. Ad esempio, è possibile adattarlo a qualsiasi periodo, come *2025*, *2026*.
**Nota**  
L’inclusione di partizioni vuote, come quelle per date future (esempio: 2025-2040), può influire sulle prestazioni delle query. Tuttavia, la proiezione delle partizioni è progettata proprio per gestire in maniera efficace date future. Per mantenere prestazioni ottimali, assicurarsi che le partizioni siano gestite con attenzione ed evitare troppe partizioni vuote quando possibile.
+ **Modello di posizione di archiviazione**: è necessario assicurarsi di aggiornarlo `storage.location.template` correttamente in base alla seguente struttura di CloudFront partizionamento e al percorso S3.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/create-cloudfront-table-partition-json.html)

  Dopo aver verificato che la struttura di CloudFront partizionamento e la struttura S3 corrispondono ai modelli richiesti, aggiornali come segue: `storage.location.template`

  ```
  'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account_id/CloudFront/${distributionid}/folder2/${year}/${month}/${day}/${hour}/folder3/'
  ```
**Nota**  
La corretta configurazione del `storage.location.template` è fondamentale per garantire la corretta archiviazione e recupero dei dati.

# Crea una tabella per CloudFront i registri in Athena utilizzando la proiezione delle partizioni con Parquet
<a name="create-cloudfront-table-partition-parquet"></a>

L'esempio seguente dell'istruzione CREATE TABLE utilizza automaticamente la proiezione delle partizioni sui CloudFront registri in Parquet, da una distribuzione specificata CloudFront fino a quella presente per una singola distribuzione. Regione AWS Dopo aver eseguito la query con esito positivo, è possibile eseguire query sulla tabella.

```
CREATE EXTERNAL TABLE `cloudfront_logs_parquet_pp`(
`date` string, 
`time` string, 
`x_edge_location` string, 
`sc_bytes` string, 
`c_ip` string, 
`cs_method` string, 
`cs_host` string, 
`cs_uri_stem` string, 
`sc_status` string, 
`cs_referer` string, 
`cs_user_agent` string, 
`cs_uri_query` string, 
`cs_cookie` string, 
`x_edge_result_type` string, 
`x_edge_request_id` string, 
`x_host_header` string, 
`cs_protocol` string, 
`cs_bytes` string, 
`time_taken` string, 
`x_forwarded_for` string, 
`ssl_protocol` string, 
`ssl_cipher` string, 
`x_edge_response_result_type` string, 
`cs_protocol_version` string, 
`fle_status` string, 
`fle_encrypted_fields` string, 
`c_port` string, 
`time_to_first_byte` string, 
`x_edge_detailed_result_type` string, 
`sc_content_type` string, 
`sc_content_len` string, 
`sc_range_start` string, 
`sc_range_end` string)
PARTITIONED BY(
 distributionid string,
 year int,
 month int,
 day int,
 hour int )
ROW FORMAT SERDE 
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe' 
STORED AS INPUTFORMAT 
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat' 
OUTPUTFORMAT 
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/CloudFront/'
TBLPROPERTIES (
'projection.distributionid.type'='enum',
'projection.distributionid.values'='E3OK0LPUNWWO3',
'projection.day.range'='01,31',
'projection.day.type'='integer',
'projection.day.digits'='2',
'projection.enabled'='true',
'projection.month.range'='01,12',
'projection.month.type'='integer',
'projection.month.digits'='2',
'projection.year.range'='2019,2025',
'projection.year.type'='integer',
'projection.hour.range'='01,12',
'projection.hour.type'='integer',
'projection.hour.digits'='2',
'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/CloudFront/${distributionid}/${year}/${month}/${day}/${hour}/')
```

Di seguito sono riportate alcune considerazioni sulle proprietà utilizzate nell’esempio precedente.
+ **Nome tabella**: il nome della tabella *`cloudfront_logs_pp`* è sostituibile. È possibile cambiarlo con il nome che si desidera.
+ **Posizione**: modificare `s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/` in modo che punti al proprio bucket Amazon S3.
+ **Distribuzione IDs**: per`projection.distributionid.values`, è possibile specificare più distribuzioni IDs se le si separano con virgole. Ad esempio, *<distributionID1>*, *<distributionID2>*.
+ **Intervallo di anni**: nel `projection.year.range`, è possibile definire l’intervallo di anni in base ai propri dati. Ad esempio, è possibile adattarlo a qualsiasi periodo, come *2025*, *2026*.
**Nota**  
L’inclusione di partizioni vuote, come quelle per date future (esempio: 2025-2040), può influire sulle prestazioni delle query. Tuttavia, la proiezione delle partizioni è progettata proprio per gestire in maniera efficace date future. Per mantenere prestazioni ottimali, assicurarsi che le partizioni siano gestite con attenzione ed evitare troppe partizioni vuote quando possibile.
+ **Modello di posizione di archiviazione**: è necessario assicurarsi di aggiornarlo `storage.location.template` correttamente in base alla seguente struttura di CloudFront partizionamento e al percorso S3.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/create-cloudfront-table-partition-parquet.html)

  Dopo aver verificato che la struttura di CloudFront partizionamento e la struttura S3 corrispondono ai modelli richiesti, aggiornali come segue: `storage.location.template`

  ```
  'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account_id/CloudFront/${distributionid}/folder2/${year}/${month}/${day}/${hour}/folder3/'
  ```
**Nota**  
La corretta configurazione del `storage.location.template` è fondamentale per garantire la corretta archiviazione e recupero dei dati.

# Crea una tabella per i log in tempo reale CloudFront
<a name="create-cloudfront-table-real-time-logs"></a>

**Per creare una tabella per i campi dei file di registro CloudFront in tempo reale**

1. Copia e incolla la seguente istruzione DDL di esempio nell'Editor di query della console Athena. L'istruzione di esempio utilizza i campi del file di registro documentati nella sezione [Real-time logs](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/real-time-logs.html) della *Amazon CloudFront Developer Guide*. Modifica il parametro `LOCATION` per il bucket Amazon S3 in cui sono archiviati i log. Per ulteriori informazioni sull'utilizzo dell'editor di query, consulta [Nozioni di base](getting-started.md).

   Questa query specifica `ROW FORMAT DELIMITED` e `FIELDS TERMINATED BY '\t'` per indicare che i campi sono delimitati da caratteri di tabulazione. Per`ROW FORMAT DELIMITED`, Athena utilizza per impostazione [LazySimpleSerDe](lazy-simple-serde.md)predefinita. Nella colonna `timestamp` viene inserito il carattere escape con l'apice inverso (`) perché è una parola riservata in Athena. Per informazioni, consulta [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md).

   L’esempio seguente contiene tutti i campi disponibili. È possibile aggiungere commenti o rimuovere campi non servono.

   ```
   CREATE EXTERNAL TABLE IF NOT EXISTS cloudfront_real_time_logs ( 
   `timestamp` STRING,
   c_ip STRING,
   time_to_first_byte BIGINT,
   sc_status BIGINT,
   sc_bytes BIGINT,
   cs_method STRING,
   cs_protocol STRING,
   cs_host STRING,
   cs_uri_stem STRING,
   cs_bytes BIGINT,
   x_edge_location STRING,
   x_edge_request_id STRING,
   x_host_header STRING,
   time_taken BIGINT,
   cs_protocol_version STRING,
   c_ip_version STRING,
   cs_user_agent STRING,
   cs_referer STRING,
   cs_cookie STRING,
   cs_uri_query STRING,
   x_edge_response_result_type STRING,
   x_forwarded_for STRING,
   ssl_protocol STRING,
   ssl_cipher STRING,
   x_edge_result_type STRING,
   fle_encrypted_fields STRING,
   fle_status STRING,
   sc_content_type STRING,
   sc_content_len BIGINT,
   sc_range_start STRING,
   sc_range_end STRING,
   c_port BIGINT,
   x_edge_detailed_result_type STRING,
   c_country STRING,
   cs_accept_encoding STRING,
   cs_accept STRING,
   cache_behavior_path_pattern STRING,
   cs_headers STRING,
   cs_header_names STRING,
   cs_headers_count BIGINT,
   primary_distribution_id STRING,
   primary_distribution_dns_name STRING,
   origin_fbl STRING,
   origin_lbl STRING,
   asn STRING
   )
   ROW FORMAT DELIMITED 
   FIELDS TERMINATED BY '\t'
   LOCATION 's3://amzn-s3-demo-bucket/'
   TBLPROPERTIES ( 'skip.header.line.count'='2' )
   ```

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `cloudfront_real_time_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.

# Risorse aggiuntive
<a name="cloudfront-logs-additional-resources"></a>

Per ulteriori informazioni sull'utilizzo di Athena per interrogare CloudFront i log, consulta i seguenti post del blog sui [AWS big data](https://aws.amazon.com/blogs/big-data/).

[Interroga facilmente Servizio AWS i log con Amazon](https://aws.amazon.com/blogs/big-data/easily-query-aws-service-logs-using-amazon-athena/) Athena (29 maggio 2019).

[Analizza i log di CloudFront accesso di Amazon su larga scala](https://aws.amazon.com/blogs/big-data/analyze-your-amazon-cloudfront-access-logs-at-scale/) (21 dicembre 2018).

[Crea un'architettura serverless per analizzare i log di CloudFront accesso di Amazon utilizzando AWS Lambda Amazon Athena e Amazon Managed Service for Apache](https://aws.amazon.com/blogs/big-data/build-a-serverless-architecture-to-analyze-amazon-cloudfront-access-logs-using-aws-lambda-amazon-athena-and-amazon-kinesis-analytics/) Flink (26 maggio 2017).

# AWS CloudTrail Registri delle interrogazioni
<a name="cloudtrail-logs"></a>

AWS CloudTrail è un servizio che registra chiamate ed eventi AWS API per gli account Amazon Web Services. 

CloudTrail i log includono dettagli su tutte le chiamate API effettuate al tuo account Servizi AWS, inclusa la console. CloudTrail genera file di registro crittografati e li archivia in Amazon S3. Per ulteriori informazioni, consulta la [Guida per l'utente AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html). 

**Nota**  
Se desideri eseguire query SQL sulle informazioni sugli CloudTrail eventi tra account, regioni e date, prendi in considerazione l'utilizzo CloudTrail di Lake. CloudTrail Lake è un' AWS alternativa alla creazione di percorsi che aggregano le informazioni di un'azienda in un unico archivio di dati sugli eventi ricercabile. Invece di utilizzare lo storage bucket Amazon S3, memorizza gli eventi in un data lake, che consente di effettuare query più ricche e più rapide. È possibile utilizzarlo per creare query SQL che cercano eventi tra organizzazioni, regioni e intervalli di tempo personalizzati. Poiché esegui le query su CloudTrail Lake all'interno della CloudTrail console stessa, l'utilizzo di CloudTrail Lake non richiede Athena. Per ulteriori informazioni, consulta la documentazione di [CloudTrail Lake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html).

L'utilizzo di Athena con CloudTrail i log è un modo efficace per migliorare l'analisi delle attività. Servizio AWS Ad esempio, puoi utilizzare le query per identificare le tendenze e isolare con maggiore precisione le attività in base ad attributi specifici, ad esempio l'indirizzo IP di origine o un utente.

Un'applicazione comune consiste nell'utilizzare CloudTrail i log per analizzare l'attività operativa per motivi di sicurezza e conformità. Per informazioni su un esempio dettagliato, consulta il post sul blog AWS Big Data, [Analyze security, compliance and operations activity using AWS CloudTrail and Amazon Athena](https://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/).

È possibile usare Athena per eseguire query su questi file di log direttamente da Amazon S3, specificando la voce `LOCATION` dei file di log. Ci sono due modi per farlo:
+ Creando tabelle per i file di CloudTrail log direttamente dalla CloudTrail console.
+ Creando manualmente tabelle per i file di CloudTrail registro nella console Athena.

**Topics**
+ [Comprendi CloudTrail i log e le tabelle Athena](create-cloudtrail-table-understanding.md)
+ [Usa la CloudTrail console per creare una tabella Athena per i log CloudTrail](create-cloudtrail-table-ct.md)
+ [Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md)
+ [Crea una tabella per un percorso a livello di organizzazione utilizzando il partizionamento manuale](create-cloudtrail-table-org-wide-trail.md)
+ [Crea la tabella per i CloudTrail log in Athena usando la proiezione delle partizioni](create-cloudtrail-table-partition-projection.md)
+ [Esempi di interrogazioni di CloudTrail registro](query-examples-cloudtrail-logs.md)

# Comprendi CloudTrail i log e le tabelle Athena
<a name="create-cloudtrail-table-understanding"></a>

Prima di iniziare a creare tabelle, è necessario comprendere meglio come vengono CloudTrail archiviati i dati. Questo può aiutarti a creare le tabelle di cui hai bisogno, indipendentemente dal fatto che tu le crei dalla CloudTrail console o da Athena.

CloudTrail salva i log come file di testo JSON in formato gzip compresso (). `*.json.gz` La posizione dei file di registro dipende dalla modalità di configurazione dei percorsi, dalle regioni in cui si effettua la Regione AWS registrazione e da altri fattori. 

Per ulteriori informazioni su dove vengono archiviati i log, la struttura JSON e i contenuti dei file di record, consulta i seguenti argomenti nella [Guida per l'utente di AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html):
+  [Individuazione dei file di CloudTrail registro](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-find-log-files.html) 
+  [CloudTrail Esempi di file di registro](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-log-file-examples.html) 
+  [CloudTrail contenuti dei record](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html)
+  [CloudTrail riferimento all'evento](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference.html) 

Per raccogliere i log e salvarli su Amazon S3, CloudTrail abilita da. Console di gestione AWS Per ulteriori informazioni, consulta [Creazione di un percorso](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html) nella *Guida per l'utente di AWS CloudTrail *.

# Usa la CloudTrail console per creare una tabella Athena per i log CloudTrail
<a name="create-cloudtrail-table-ct"></a>

È possibile creare una tabella Athena non partizionata per CloudTrail interrogare i log direttamente dalla console. CloudTrail La creazione di una tabella Athena dalla CloudTrail console richiede l'accesso con un ruolo con autorizzazioni sufficienti per creare tabelle in Athena.

**Nota**  
Non è possibile utilizzare la CloudTrail console per creare una tabella Athena per i log degli itinerari organizzativi. Crea invece la tabella manualmente utilizzando la console Athena in modo da poter specificare la posizione di archiviazione corretta. Per ulteriori informazioni sui percorsi dell'organizzazione, consulta [Creazione di un percorso per un'organizzazione](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/creating-trail-organization.html) nella *Guida per l'utente di AWS CloudTrail *.
+ Per informazioni sull'impostazione delle autorizzazioni di gruppo per Athena, consulta [Configurare l’accesso amministrativo e programmatico](setting-up.md).
+ Per informazioni sulla creazione di una tabella con partizioni, consulta [Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md).

**Per creare una tabella Athena per un CloudTrail percorso utilizzando la console CloudTrail**

1. Apri la CloudTrail console all'indirizzo [https://console.aws.amazon.com/cloudtrail/](https://console.aws.amazon.com/cloudtrail/).

1. Nel riquadro di navigazione scegliere **Event history** (Cronologia eventi). 

1. Scegli **Crea la tabella Athena**.  
![\[Scegli Crea la tabella Athena\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/cloudtrail-logs-create-athena-table.png)

1. Per **Storage location** (Posizione di archiviazione), utilizza la freccia giù per selezionare il bucket Amazon S3 in cui sono archiviati i file di log per il trail sul quale eseguire le query.
**Nota**  
Per trovare il nome del bucket associato a un percorso, scegli **Percorsi** nel riquadro di CloudTrail navigazione e visualizza la colonna del **bucket S3** del percorso. Per visualizzare la posizione del bucket in Amazon S3, scegliere il link per il bucket nella colonna **Bucket S3**. In questo modo la console Amazon S3 viene aperta alla posizione del CloudTrail bucket. 

1. Scegliere **Create table (Crea tabella)**. La tabella viene creata con un nome di default che include il nome del bucket Amazon S3.

# Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale
<a name="create-cloudtrail-table"></a>

È possibile creare manualmente tabelle per i file di CloudTrail registro nella console Athena e quindi eseguire query in Athena.

**Per creare una tabella Athena per un CloudTrail percorso utilizzando la console Athena**

1. Copia e incolla la seguente istruzione DDL nell’editor di query della console Athena, quindi modificala in base alle tue esigenze. Tieni presente che, poiché i file di CloudTrail registro non sono una traccia ordinata di chiamate API pubbliche, i campi nei file di registro non vengono visualizzati in un ordine specifico.

   ```
   CREATE EXTERNAL TABLE cloudtrail_logs (
   eventversion STRING,
   useridentity STRUCT<
                  type:STRING,
                  principalid:STRING,
                  arn:STRING,
                  accountid:STRING,
                  invokedby:STRING,
                  accesskeyid:STRING,
                  username:STRING,
                  onbehalfof: STRUCT<
                       userid: STRING,
                       identitystorearn: STRING>,
     sessioncontext:STRUCT<
       attributes:STRUCT<
                  mfaauthenticated:STRING,
                  creationdate:STRING>,
       sessionissuer:STRUCT<  
                  type:STRING,
                  principalid:STRING,
                  arn:STRING, 
                  accountid:STRING,
                  username:STRING>,
       ec2roledelivery:string,
       webidfederationdata: STRUCT<
                  federatedprovider: STRING,
                  attributes: map<string,string>>
     >
   >,
   eventtime STRING,
   eventsource STRING,
   eventname STRING,
   awsregion STRING,
   sourceipaddress STRING,
   useragent STRING,
   errorcode STRING,
   errormessage STRING,
   requestparameters STRING,
   responseelements STRING,
   additionaleventdata STRING,
   requestid STRING,
   eventid STRING,
   resources ARRAY<STRUCT<
                  arn:STRING,
                  accountid:STRING,
                  type:STRING>>,
   eventtype STRING,
   apiversion STRING,
   readonly STRING,
   recipientaccountid STRING,
   serviceeventdetails STRING,
   sharedeventid STRING,
   vpcendpointid STRING,
   vpcendpointaccountid STRING,
   eventcategory STRING,
   addendum STRUCT<
     reason:STRING,
     updatedfields:STRING,
     originalrequestid:STRING,
     originaleventid:STRING>,
   sessioncredentialfromconsole STRING,
   edgedevicedetails STRING,
   tlsdetails STRUCT<
     tlsversion:STRING,
     ciphersuite:STRING,
     clientprovidedhostheader:STRING>
   )
   PARTITIONED BY (region string, year string, month string, day string)
   ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe'
   STORED AS INPUTFORMAT 'com.amazon.emr.cloudtrail.CloudTrailInputFormat'
   OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
   LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/Account_ID/';
   ```
**Nota**  
Suggeriamo di utilizzare il `org.apache.hive.hcatalog.data.JsonSerDe` mostrato nell’esempio. Sebbene a `com.amazon.emr.hive.serde.CloudTrailSerde` esista, attualmente non gestisce alcuni dei campi più recenti. CloudTrail 

1. (Facoltativo) Rimuovi tutti i campi non obbligatori per la tabella. Se è necessario leggere solo un determinato set di colonne, la definizione della tabella può escludere le altre colonne.

1. Modifica `s3://amzn-s3-demo-bucket/AWSLogs/Account_ID/` perché punti al bucket Amazon S3 che contiene i dati di log che vuoi interrogare. L'esempio utilizza un `LOCATION` valore di log per un determinato account, ma è possibile utilizzare il grado di specificità più adatta alla tua applicazione. Ad esempio:
   + Per analizzare i dati provenienti da più account, puoi eseguire il rollback dell'identificatore `LOCATION` per selezionare tutti gli `AWSLogs` con `LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/'`.
   + Per analizzare i dati provenienti da una data, account e regione specifici, utilizza `LOCATION 's3://amzn-s3-demo-bucket/123456789012/CloudTrail/us-east-1/2016/03/14/'.` 
   + Per analizzare i dati sulle attività di rete anziché gli eventi di gestione, sostituire `/CloudTrail/` nella clausola `LOCATION` con `/CloudTrail-NetworkActivity/`. 

   Indicando il livello più elevato nella gerarchia degli oggetti hai la massima flessibilità nelle query con Athena.

1. Verificare che i campi siano elencati correttamente. Per ulteriori informazioni sull'elenco completo dei campi in un CloudTrail record, vedere il [contenuto del CloudTrail record](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html).

   L’istruzione di esempio `CREATE TABLE` nella Fase 1 utilizza il [JSON Hive SerDe](hive-json-serde.md). Nell’esempio, i campi `requestparameters`, `responseelements` e `additionaleventdata` sono elencati come tipo `STRING` nella query, ma sono dati di tipo `STRUCT` utilizzati in JSON. Pertanto, per estrarre i dati da questi campi, utilizza le funzioni `JSON_EXTRACT`. Per ulteriori informazioni, consulta [Estrarre dati JSON da stringhe](extracting-data-from-JSON.md). Per migliorare le prestazioni, l'esempio partiziona i dati per anno Regione AWS, mese e giorno.

1. Esegui l'istruzione `CREATE TABLE` nella console Athena.

1. Utilizzare il comando [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) per caricare le partizioni in modo da poterle interrogare, come nell'esempio seguente.

   ```
   ALTER TABLE table_name ADD 
      PARTITION (region='us-east-1',
                 year='2019',
                 month='02',
                 day='01')
      LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/Account_ID/CloudTrail/us-east-1/2019/02/01/'
   ```

# Crea una tabella per un percorso a livello di organizzazione utilizzando il partizionamento manuale
<a name="create-cloudtrail-table-org-wide-trail"></a>

Per creare una tabella per i file di CloudTrail registro a livello di organizzazione in Athena, segui la procedura riportata di seguito[Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md), ma apporta le modifiche indicate nella procedura seguente.

**Per creare una tabella Athena per i registri a livello di organizzazione CloudTrail**

1. Nell'istruzione `CREATE TABLE`, modifica la clausola `LOCATION` per includere l'ID dell'organizzazione, come nell'esempio seguente:

   ```
   LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/organization_id/'
   ```

1. Nella clausola `PARTITIONED BY`, aggiungi una voce per l'ID account sotto forma di stringa, come nell'esempio seguente:

   ```
   PARTITIONED BY (account string, region string, year string, month string, day string)
   ```

   L'esempio seguente mostra solo il risultato combinato:

   ```
   ...
   
   PARTITIONED BY (account string, region string, year string, month string, day string) 
   ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe'
   STORED AS INPUTFORMAT 'com.amazon.emr.cloudtrail.CloudTrailInputFormat'
   OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
   LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/organization_id/Account_ID/CloudTrail/'
   ```

1. Nella clausola `ADD PARTITION` dell'istruzione `ALTER TABLE`, includi l'ID dell'account, come nell'esempio seguente:

   ```
   ALTER TABLE table_name ADD
   PARTITION (account='111122223333',
   region='us-east-1',
   year='2022',
   month='08',
   day='08')
   ```

1. Nella clausola `LOCATION` dell'istruzione `ALTER TABLE`, includi l'ID dell'organizzazione, l'ID dell'account e la partizione che desideri aggiungere, come nell'esempio seguente:

   ```
   LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/organization_id/Account_ID/CloudTrail/us-east-1/2022/08/08/'
   ```

   L'istruzione di esempio `ALTER TABLE` seguente mostra solo il risultato combinato:

   ```
   ALTER TABLE table_name ADD
   PARTITION (account='111122223333',
   region='us-east-1',
   year='2022',
   month='08',
   day='08')
   LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/organization_id/111122223333/CloudTrail/us-east-1/2022/08/08/'
   ```

Nota che, in un’organizzazione di grandi dimensioni, l’utilizzo di questo metodo per aggiungere e gestire manualmente una partizione per ogni ID di account dell’organizzazione può essere complicato. In uno scenario del genere, prendi in considerazione l'utilizzo di CloudTrail Lake anziché Athena. CloudTrail Lake in uno scenario del genere offre i seguenti vantaggi:
+ Aggrega automaticamente i log di un'intera organizzazione
+ Non richiede la configurazione o la manutenzione di partizioni o di una tabella Athena
+ Le interrogazioni vengono eseguite direttamente nella console CloudTrail 
+ Utilizza un linguaggio di query compatibile con SQL

Per ulteriori informazioni, consulta [Utilizzo di AWS CloudTrail Lake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html) nella *Guida per l’utente di AWS CloudTrail *. 

# Crea la tabella per i CloudTrail log in Athena usando la proiezione delle partizioni
<a name="create-cloudtrail-table-partition-projection"></a>

Poiché CloudTrail 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. 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 che segue utilizza automaticamente la proiezione delle partizioni sui CloudTrail registri da una data specificata a quella attuale per un singolo registro. Regione AWS Nelle `storage.location.template` clausole `LOCATION` and, sostituite i *aws-region* segnaposto *bucket**account-id*, e con valori corrispondentemente identici. Per`projection.timestamp.range`, sostituisci*2020*/*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 cloudtrail_logs_pp(
    eventversion STRING,
    useridentity STRUCT<
        type: STRING,
        principalid: STRING,
        arn: STRING,
        accountid: STRING,
        invokedby: STRING,
        accesskeyid: STRING,
        username: STRING,
        onbehalfof: STRUCT<
             userid: STRING,
             identitystorearn: STRING>,
        sessioncontext: STRUCT<
            attributes: STRUCT<
                mfaauthenticated: STRING,
                creationdate: STRING>,
            sessionissuer: STRUCT<
                type: STRING,
                principalid: STRING,
                arn: STRING,
                accountid: STRING,
                username: STRING>,
            ec2roledelivery:string,
            webidfederationdata: STRUCT<
                federatedprovider: STRING,
                attributes: map<string,string>>
        >
    >,
    eventtime STRING,
    eventsource STRING,
    eventname STRING,
    awsregion STRING,
    sourceipaddress STRING,
    useragent STRING,
    errorcode STRING,
    errormessage STRING,
    requestparameters STRING,
    responseelements STRING,
    additionaleventdata STRING,
    requestid STRING,
    eventid STRING,
    readonly STRING,
    resources ARRAY<STRUCT<
        arn: STRING,
        accountid: STRING,
        type: STRING>>,
    eventtype STRING,
    apiversion STRING,
    recipientaccountid STRING,
    serviceeventdetails STRING,
    sharedeventid STRING,
    vpcendpointid STRING,
    vpcendpointaccountid STRING,
    eventcategory STRING,
    addendum STRUCT<
      reason:STRING,
      updatedfields:STRING,
      originalrequestid:STRING,
      originaleventid:STRING>,
    sessioncredentialfromconsole STRING,
    edgedevicedetails STRING,
    tlsdetails STRUCT<
      tlsversion:STRING,
      ciphersuite:STRING,
      clientprovidedhostheader:STRING>
  )
PARTITIONED BY (
   `timestamp` string)
ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe'
STORED AS INPUTFORMAT 'com.amazon.emr.cloudtrail.CloudTrailInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
  's3://amzn-s3-demo-bucket/AWSLogs/account-id/CloudTrail/aws-region'
TBLPROPERTIES (
  'projection.enabled'='true', 
  'projection.timestamp.format'='yyyy/MM/dd', 
  'projection.timestamp.interval'='1', 
  'projection.timestamp.interval.unit'='DAYS', 
  'projection.timestamp.range'='2020/01/01,NOW', 
  'projection.timestamp.type'='date', 
  'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account-id/CloudTrail/aws-region/${timestamp}')
```

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

# Esempi di interrogazioni di CloudTrail registro
<a name="query-examples-cloudtrail-logs"></a>

L'esempio seguente mostra una parte di una query che restituisce tutte le richieste anonime (non firmate) dalla tabella creata per i registri CloudTrail degli eventi. Questa query seleziona le richieste in cui `useridentity.accountid` è anonimo e `useridentity.arn` non è specificato:

```
SELECT *
FROM cloudtrail_logs
WHERE 
    eventsource = 's3.amazonaws.com' AND 
    eventname in ('GetObject') AND 
    useridentity.accountid = 'anonymous' AND 
    useridentity.arn IS NULL AND
    requestparameters LIKE '%[your bucket name ]%';
```

Per ulteriori informazioni, consulta il post sul blog AWS Big Data [Analyze security, compliance and operations activity using AWS CloudTrail and Amazon Athena](https://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/).

## Interroga i campi annidati nei log CloudTrail
<a name="cloudtrail-logs-nested-fields"></a>

Poiché i campi `userIdentity` e `resources` sono tipi di dati nidificati, l’esecuzioni di query richiede un trattamento speciale.

L'oggetto `userIdentity` è costituito da tipi nidificati `STRUCT`. È possibile eseguire query utilizzando un punto per separare i campi, come nell'esempio seguente:

```
SELECT 
    eventsource, 
    eventname,
    useridentity.sessioncontext.attributes.creationdate,
    useridentity.sessioncontext.sessionissuer.arn
FROM cloudtrail_logs
WHERE useridentity.sessioncontext.sessionissuer.arn IS NOT NULL
ORDER BY eventsource, eventname
LIMIT 10
```

Il campo `resources` è un array di oggetti `STRUCT`. Per questi array, utilizzare `CROSS JOIN UNNEST` per annullare l'array in modo da poter interrogare i suoi oggetti.

L'esempio seguente restituisce tutte le righe in cui la risorsa ARN termina in `example/datafile.txt`. Per la leggibilità, la funzione [replace](https://prestodb.io/docs/current/functions/string.html#replace) rimuove la sottostringa iniziale `arn:aws:s3:::` dall'ARN.

```
SELECT 
    awsregion,
    replace(unnested.resources_entry.ARN,'arn:aws:s3:::') as s3_resource,
    eventname,
    eventtime,
    useragent
FROM cloudtrail_logs t
CROSS JOIN UNNEST(t.resources) unnested (resources_entry)
WHERE unnested.resources_entry.ARN LIKE '%example/datafile.txt'
ORDER BY eventtime
```

Di seguito sono illustrati alcuni esempi di query per gli eventi `DeleteBucket`. La query estrae il nome del bucket e l'ID account a cui appartiene il bucket dall'oggetto `resources`.

```
SELECT 
    awsregion,
    replace(unnested.resources_entry.ARN,'arn:aws:s3:::') as deleted_bucket,
    eventtime AS time_deleted,
    useridentity.username, 
    unnested.resources_entry.accountid as bucket_acct_id 
FROM cloudtrail_logs t
CROSS JOIN UNNEST(t.resources) unnested (resources_entry)
WHERE eventname = 'DeleteBucket'
ORDER BY eventtime
```

Per ulteriori informazioni sull'annullamento della nidificazione, consulta [Filtrare le matrici](filtering-arrays.md).

## Suggerimenti per l'interrogazione dei log CloudTrail
<a name="tips-for-querying-cloudtrail-logs"></a>

Quando esplori i dati di CloudTrail registro, considera quanto segue:
+ Prima di eseguire query sui log, verifica che la tabella di log sia uguale a quella definita in [Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md). Se non è la prima tabella, elimina la tabella esistente utilizzando il comando: `DROP TABLE cloudtrail_logs`.
+ Dopo aver eliminato la tabella esistente, ricreala. Per ulteriori informazioni, consulta [Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md).

  Verifica che i campi della query Athena siano elencati correttamente. Per informazioni sull'elenco completo dei campi in un CloudTrail record, consulta il [contenuto del CloudTrail record](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html). 

  Se la query include campi nei formati JSON, ad esempio `STRUCT`, estrarre i dati da JSON. Per ulteriori informazioni, consulta [Estrarre dati JSON da stringhe](extracting-data-from-JSON.md). 

  Alcuni suggerimenti per eseguire interrogazioni sulla tabella: CloudTrail 
+ Inizia osservando quali utenti hanno eseguito specifiche operazioni API e gli indirizzi IP di origine.
+ Utilizza la seguente query SQL di base come modello. Incolla la query nella console Athena ed eseguila.

  ```
  SELECT
   useridentity.arn,
   eventname,
   sourceipaddress,
   eventtime
  FROM cloudtrail_logs
  LIMIT 100;
  ```
+ Modifica la query per esplorare ulteriormente i dati.
+ Per migliorare le prestazioni, includi la clausola `LIMIT` per ottenere uno specifico sottoinsieme di righe.

# Eseguire query sui log Amazon EMR
<a name="emr-logs"></a>

Amazon EMR e le applicazioni Big Data che vengono eseguite su Amazon EMR generano file di log. I file di log vengono scritti sul [nodo primario](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html), ed è anche possibile configurare Amazon EMR per consentire la loro archiviazione automatica in Amazon S3. È possibile utilizzare Amazon Athena per eseguire query su questi log per identificare eventi e tendenze per applicazioni e cluster. Per ulteriori informazioni sui tipi di file di log in Amazon EMR e sul loro salvataggio in Amazon S3, consulta [Visualizzazione di file di log](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-manage-view-web-log-files.html) nella *Guida alla gestione di Amazon EMR*.

**Topics**
+ [Creare ed eseguire query su una tabella di base basata sui file di log di Amazon EMR](emr-create-table.md)
+ [Creare ed eseguire query su una tabella partizionata in base ai log di Amazon EMR](emr-create-table-partitioned.md)

# Creare ed eseguire query su una tabella di base basata sui file di log di Amazon EMR
<a name="emr-create-table"></a>

Nell'esempio seguente viene creata una tabella di base `myemrlogs`, basata sui file di log salvati in `s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/elasticmapreduce/`. La posizione Amazon S3 utilizzata negli esempi seguenti riflette lo schema della posizione di registro predefinita per un cluster EMR creato dall'account Amazon Web Services nella regione. *123456789012* *us-west-2* Se utilizzi una posizione personalizzata, il modello è s3://amzn-s3-demo-bucket/. *ClusterID*

Per informazioni sulla creazione di una tabella partizionata per migliorare potenzialmente le prestazioni delle query e ridurre il trasferimento dei dati, consulta [Creare ed eseguire query su una tabella partizionata in base ai log di Amazon EMR](emr-create-table-partitioned.md).

```
CREATE EXTERNAL TABLE `myemrlogs`(
  `data` string COMMENT 'from deserializer')
ROW FORMAT DELIMITED  
FIELDS TERMINATED BY '|'
LINES TERMINATED BY '\n'
STORED AS INPUTFORMAT 
  'org.apache.hadoop.mapred.TextInputFormat' 
OUTPUTFORMAT 
  'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
  's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6'
```

## Query di esempio
<a name="emr-example-queries-basic"></a>

Le query di esempio seguenti possono essere eseguite sulla tabella `myemrlogs` creata dall'esempio precedente.

**Example Esecuzione di query su log di fase per occorrenze di ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**  

```
SELECT data,
        "$PATH"
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'s-86URH188Z6B1')
        AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```

**Example Esecuzione di query su log di istanze specifiche, i-00b3c0a839ece0a9c, per ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**  

```
SELECT "data",
        "$PATH" AS filepath
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'i-00b3c0a839ece0a9c')
        AND regexp_like("$PATH",'state')
        AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```

**Example Esecuzione di query su log di applicazioni Presto per ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**  

```
SELECT "data",
        "$PATH" AS filepath
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'presto')
        AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```

**Example Esecuzione di query su log di applicazioni Namenode per ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**  

```
SELECT "data",
        "$PATH" AS filepath
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'namenode')
        AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```

**Example Esecuzione di query su tutti i log per data e ora per ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**  

```
SELECT distinct("$PATH") AS filepath
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'2019-07-23-10')
        AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```

# Creare ed eseguire query su una tabella partizionata in base ai log di Amazon EMR
<a name="emr-create-table-partitioned"></a>

Questi esempi utilizzano la stessa posizione dei log per creare una tabella Athena, ma la tabella viene partizionata e viene quindi creata una partizione per ogni posizione. Per ulteriori informazioni, consulta [Come partizionare i dati](partitions.md).

La query seguente crea la tabella partizionata denominata `mypartitionedemrlogs`:

```
CREATE EXTERNAL TABLE `mypartitionedemrlogs`(
  `data` string COMMENT 'from deserializer')
 partitioned by (logtype string)
ROW FORMAT DELIMITED  
FIELDS TERMINATED BY '|'
LINES TERMINATED BY '\n'
STORED AS INPUTFORMAT 
  'org.apache.hadoop.mapred.TextInputFormat' 
OUTPUTFORMAT 
 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6'
```

Le istruzioni di query seguenti creano quindi partizioni di tabella basate su sottodirectory per diversi tipi di log che Amazon EMR crea in Amazon S3:

```
ALTER TABLE mypartitionedemrlogs ADD
     PARTITION (logtype='containers')
     LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/containers/'
```

```
ALTER TABLE mypartitionedemrlogs ADD
     PARTITION (logtype='hadoop-mapreduce')
     LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/hadoop-mapreduce/'
```

```
ALTER TABLE mypartitionedemrlogs ADD
     PARTITION (logtype='hadoop-state-pusher')
     LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/hadoop-state-pusher/'
```

```
ALTER TABLE mypartitionedemrlogs ADD
     PARTITION (logtype='node')
     LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/node/'
```

```
ALTER TABLE mypartitionedemrlogs ADD
     PARTITION (logtype='steps')
     LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/steps/'
```

Dopo aver creato le partizioni, puoi eseguire una query `SHOW PARTITIONS` nella tabella per confermare:

```
SHOW PARTITIONS mypartitionedemrlogs;
```

## Query di esempio
<a name="emr-example-queries-partitioned"></a>

Negli esempi seguenti vengono illustrate le query per voci di log specifiche che utilizzano la tabella e le partizioni create dagli esempi precedenti.

**Example Esecuzione di query sui log di applicazioni application\$11561661818238\$10002 nella partizione dei contenitori per ERROR o WARN**  

```
SELECT data,
        "$PATH"
FROM "default"."mypartitionedemrlogs"
WHERE logtype='containers'
        AND regexp_like("$PATH",'application_1561661818238_0002')
        AND regexp_like(data, 'ERROR|WARN') limit 100;
```

**Example Esecuzione di query sulla partizione Hadoop-Mapreduce per l'attività job\$11561661818238\$10004 e Failed Reduces**  

```
SELECT data,
        "$PATH"
FROM "default"."mypartitionedemrlogs"
WHERE logtype='hadoop-mapreduce'
        AND regexp_like(data,'job_1561661818238_0004|Failed Reduces') limit 100;
```

**Example Esecuzione di query sui log Hive nella partizione dei nodi per l'ID query 056e0609-33e1-4611-956c-7a31b42d2663**  

```
SELECT data,
        "$PATH"
FROM "default"."mypartitionedemrlogs"
WHERE logtype='node'
        AND regexp_like("$PATH",'hive')
        AND regexp_like(data,'056e0609-33e1-4611-956c-7a31b42d2663') limit 100;
```

**Example Esecuzione di query sui log ResourceManager nella partizione dei nodi per l'applicazione 1567660019320\$10001\$101\$1000001**  

```
SELECT data,
        "$PATH"
FROM "default"."mypartitionedemrlogs"
WHERE logtype='node'
        AND regexp_like(data,'resourcemanager')
        AND regexp_like(data,'1567660019320_0001_01_000001') limit 100
```

# Registri AWS Global Accelerator del flusso di query
<a name="querying-global-accelerator-flow-logs"></a>

Puoi utilizzarli AWS Global Accelerator per creare acceleratori che indirizzano il traffico di rete verso endpoint ottimali sulla rete globale. AWS [Per ulteriori informazioni su Global Accelerator, consulta What is. AWS Global Accelerator](https://docs.aws.amazon.com/global-accelerator/latest/dg/what-is-global-accelerator.html)

I log di flusso Global Accelerator ti consentono di acquisire informazioni sul traffico degli indirizzi IP in entrata e in uscita dalle interfacce di rete negli acceleratori. I dati dei log di flusso vengono pubblicati in Amazon S3, dove è possibile recuperare e visualizzare i dati. Per ulteriori informazioni, consulta [Log di flusso in AWS Global Accelerator](https://docs.aws.amazon.com/global-accelerator/latest/dg/monitoring-global-accelerator.flow-logs.html).

Puoi utilizzare Athena per eseguire query sui log di flusso Global Accelerator creando una tabella che ne specifica la posizione in Amazon S3.

**Per creare la tabella per i log di flusso di Global Accelerator**

1. Copiare e incollare la seguente istruzione DDL nella console Athena. Questa query specifica *ROW FORMAT DELIMITED* e omette di specificare a [SerDe](serde-reference.md), il che significa che la query utilizza il. [`LazySimpleSerDe`](lazy-simple-serde.md) In questa query, i campi terminano con uno spazio.

   ```
   CREATE EXTERNAL TABLE IF NOT EXISTS aga_flow_logs (
     version string,
     account string,
     acceleratorid string,
     clientip string,
     clientport int,
     gip string,
     gipport int,
     endpointip string,
     endpointport int,
     protocol string,
     ipaddresstype string,
     numpackets bigint,
     numbytes int,
     starttime int,
     endtime int,
     action string,
     logstatus string,
     agasourceip string,
     agasourceport int,
     endpointregion string,
     agaregion string,
     direction string,
     vpc_id string,
     reject_reason string
   )
   PARTITIONED BY (dt string)
   ROW FORMAT DELIMITED
   FIELDS TERMINATED BY ' '
   LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/account_id/globalaccelerator/region/'
   TBLPROPERTIES ("skip.header.line.count"="1");
   ```

1. Modificare il valore `LOCATION` in modo che punti al bucket Amazon S3 che contiene i dati di log.

   ```
   's3://amzn-s3-demo-bucket/prefix/AWSLogs/account_id/globalaccelerator/region_code/'
   ```

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `aga_flow_logs`, rendendo i dati in essa contenuti disponibili per l'esecuzione di query.

1. Creare partizioni per leggere i dati, come nella seguente query di esempio. La query crea una singola partizione per una data specificata. Sostituire i segnaposto per data e posizione.

   ```
   ALTER TABLE aga_flow_logs
   ADD PARTITION (dt='YYYY-MM-dd')
   LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/account_id/globalaccelerator/region_code/YYYY/MM/dd';
   ```

## Query di esempio per i log di flusso AWS Global Accelerator
<a name="querying-global-accelerator-flow-logs-examples"></a>

**Example Elencare le richieste che passano attraverso una edge location specifica**  
La query di esempio seguente elenca le richieste passate attraverso la edge location LHR. Utilizza l'operatore `LIMIT` per limitare il numero di log di cui eseguire la query alla volta.  

```
SELECT 
  clientip, 
  agaregion, 
  protocol, 
  action 
FROM 
  aga_flow_logs 
WHERE 
  agaregion LIKE 'LHR%' 
LIMIT 
  100;
```

**Example Elencare gli indirizzi IP dell'endpoint che ricevono la maggior parte delle richieste HTTPS**  
Utilizza la query seguente per verificare quali indirizzi IP dell'endpoint ricevono il numero più elevato di richieste HTTPS. La query conta il numero di pacchetti ricevuti sulla porta HTTPS 443, li raggruppa in base all'indirizzo IP di destinazione e restituisce i primi 10 indirizzi IP.  

```
SELECT 
  SUM(numpackets) AS packetcount, 
  endpointip 
FROM 
  aga_flow_logs 
WHERE 
  endpointport = 443 
GROUP BY 
  endpointip 
ORDER BY 
  packetcount DESC 
LIMIT 
  10;
```

# Interroga GuardDuty i risultati di Amazon
<a name="querying-guardduty"></a>

[Amazon GuardDuty](https://aws.amazon.com/guardduty/) è un servizio di monitoraggio della sicurezza che aiuta a identificare attività impreviste e potenzialmente non autorizzate o dannose nel tuo AWS ambiente. Quando rileva attività impreviste e potenzialmente dannose, GuardDuty genera [risultati](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_findings.html) di sicurezza che puoi esportare in Amazon S3 per l'archiviazione e l'analisi. Dopo aver esportato i risultati in Amazon S3, è possibile utilizzare Athena per eseguire le query. Questo articolo mostra come creare una tabella in Athena per i GuardDuty risultati e interrogarli.

Per ulteriori informazioni su Amazon GuardDuty, consulta la [Amazon GuardDuty User Guide](https://docs.aws.amazon.com/guardduty/latest/ug/).

## Prerequisiti
<a name="querying-guardduty-prerequisites"></a>
+ Abilita la GuardDuty funzionalità per esportare i risultati in Amazon S3. Per i passaggi, consulta [Esportazione dei risultati](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_exportfindings.html) nella Amazon GuardDuty User Guide.

## Crea una tabella in Athena per i risultati GuardDuty
<a name="querying-guardduty-creating-a-table-in-athena-for-guardduty-findings"></a>

Per interrogare GuardDuty i tuoi risultati con Athena, devi creare una tabella per essi.

**Per creare una tabella in Athena per i risultati GuardDuty**

1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Incollare la seguente istruzione DDL nella console Athena. Modifica i valori in `LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/account-id/GuardDuty/'` modo che rimandino ai tuoi GuardDuty risultati in Amazon S3.

   ```
   CREATE EXTERNAL TABLE `gd_logs` (
     `schemaversion` string,
     `accountid` string,
     `region` string,
     `partition` string,
     `id` string,
     `arn` string,
     `type` string,
     `resource` string,
     `service` string,
     `severity` string,
     `createdat` string,
     `updatedat` string,
     `title` string,
     `description` string)
   ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
    LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/account-id/GuardDuty/'
    TBLPROPERTIES ('has_encrypted_data'='true')
   ```
**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 

1. Eseguire la query nella console Athena per registrare la tabella `gd_logs`. Al termine della query, i risultati sono pronti per le query da Athena.

## Query di esempio
<a name="querying-guardduty-examples"></a>

Gli esempi seguenti mostrano come interrogare GuardDuty i risultati di Athena.

**Example Estrazione dei dati DNS**  
La seguente query restituisce informazioni sulle EC2 istanze Amazon che potrebbero esfiltrare dati tramite query DNS.  

```
SELECT
    title,
    severity,
    type,
    id AS FindingID,
    accountid,
    region,
    createdat,
    updatedat,
    json_extract_scalar(service, '$.count') AS Count,
    json_extract_scalar(resource, '$.instancedetails.instanceid') AS InstanceID,
    json_extract_scalar(service, '$.action.actiontype') AS DNS_ActionType,
    json_extract_scalar(service, '$.action.dnsrequestaction.domain') AS DomainName,
    json_extract_scalar(service, '$.action.dnsrequestaction.protocol') AS protocol,
    json_extract_scalar(service, '$.action.dnsrequestaction.blocked') AS blocked
FROM gd_logs
WHERE type = 'Trojan:EC2/DNSDataExfiltration'
ORDER BY severity DESC
```

**Example - Accesso utente IAM non autorizzato**  
La query seguente restituisce tutti i tipi di esiti `UnauthorizedAccess:IAMUser` per un'entità principale IAM da tutte le Regioni.   

```
SELECT title,
         severity,
         type,
         id,
         accountid,
         region,
         createdat,
         updatedat,
         json_extract_scalar(service, '$.count') AS Count, 
         json_extract_scalar(resource, '$.accesskeydetails.username') AS IAMPrincipal, 
         json_extract_scalar(service,'$.action.awsapicallaction.api') AS APIActionCalled
FROM gd_logs
WHERE type LIKE '%UnauthorizedAccess:IAMUser%' 
ORDER BY severity desc;
```

## GuardDuty Suggerimenti per interrogare i risultati
<a name="querying-guardduty-tips"></a>

Quando si crea la query, tenere a mente i seguenti punti.
+ Per estrarre dati dai campi JSON nidificati, utilizzare le funzioni `json_extract` o `json_extract_scalar` di Presto. Per ulteriori informazioni, consulta [Estrarre dati JSON da stringhe](extracting-data-from-JSON.md).
+ Assicurarsi che tutti i caratteri nei campi JSON siano in minuscolo.
+  Per informazioni sul download dei risultati delle query, consulta [Download dei file dei risultati delle query mediante la console Athena](saving-query-results.md).

# AWS Network Firewall Registri delle interrogazioni
<a name="querying-network-firewall-logs"></a>

AWS Network Firewall è un servizio gestito che puoi utilizzare per implementare protezioni di rete essenziali per le tue istanze di Amazon Virtual Private Cloud. AWS Network Firewall collabora con te AWS Firewall Manager in modo da poter creare politiche basate su AWS Network Firewall regole e poi applicarle centralmente a tutti i tuoi VPCs account. Per ulteriori informazioni su AWS Network Firewall, consulta [AWS Network Firewall](https://aws.amazon.com/network-firewall/).

È possibile configurare AWS Network Firewall la registrazione del traffico da inoltrare al motore stateful rules del firewall. I log forniscono informazioni dettagliate sul traffico di rete, tra cui l'ora in cui il motore con stato ha ricevuto un pacchetto, informazioni dettagliate sul pacchetto e qualsiasi operazione di regola con stato eseguita rispetto al pacchetto. I log vengono pubblicati nella destinazione di log configurata, dove è possibile recuperarli e visualizzarli. Per ulteriori informazioni, consulta [Registrazione del traffico di rete da AWS Network Firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html)nella *Guida per gli sviluppatori di AWS Network Firewall *.

**Topics**
+ [Creare ed eseguire query in una tabella per i log di avvisi](querying-network-firewall-logs-sample-alert-logs-table.md)
+ [Creare ed eseguire query in una tabella per i log di netflow](querying-network-firewall-logs-sample-netflow-logs-table.md)

# Creare ed eseguire query in una tabella per i log di avvisi
<a name="querying-network-firewall-logs-sample-alert-logs-table"></a>

1. Modificare la seguente istruzione DDL di esempio in modo che sia conforme alla struttura del log di avvisi. Potrebbe essere necessario aggiornare l'istruzione per includere le colonne per la versione più recente dei log. Per ulteriori informazioni, consulta [Contenuti di un log firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html#firewall-logging-contents) nella *Guida per gli sviluppatori di AWS Network Firewall *.

   ```
   CREATE EXTERNAL TABLE network_firewall_alert_logs (
     firewall_name string,
     availability_zone string,
     event_timestamp string,
     event struct<
       timestamp:string,
       flow_id:bigint,
       event_type:string,
       src_ip:string,
       src_port:int,
       dest_ip:string,
       dest_port:int,
       proto:string,
       app_proto:string,
       sni:string,
       tls_inspected:boolean,
       tls_error:struct<
         error_message:string>,
       revocation_check:struct<
         leaf_cert_fpr:string,
         status:string,
         action:string>,
       alert:struct<
         alert_id:string,
         alert_type:string,
         action:string,
         signature_id:int,
         rev:int,
         signature:string,
         category:string,
         severity:int,
         rule_name:string,
         alert_name:string,
         alert_severity:string,
         alert_description:string,
         file_name:string,
         file_hash:string,
         packet_capture:string,
         reference_links:array<string>
       >, 
       src_country:string, 
       dest_country:string, 
       src_hostname:string, 
       dest_hostname:string, 
       user_agent:string, 
       url:string
      >
   )
    ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
    LOCATION 's3://amzn-s3-demo-bucket/path_to_alert_logs_folder/';
   ```

1. Modificare la frase `LOCATION` per specificare la cartella per i log in Amazon S3.

1. Eseguire la query `CREATE TABLE` nell’editor di query Athena. Una volta completata la query, Athena registra la tabella `network_firewall_alert_logs`, rendendo i dati in essa contenuti pronti per le query.

## Query di esempio
<a name="querying-network-firewall-logs-alert-log-sample-query"></a>

L’esempio di query del log degli avvisi in questa sezione filtra gli eventi in cui è stata eseguita l’ispezione TLS che presentano avvisi con un livello di gravità pari o superiore a 2.

La query utilizza alias per creare intestazioni di colonna di output che mostrano a cosa appartiene la colonna `struct`. Ad esempio, l’intestazione di colonna del campo `event.alert.category` è `event_alert_category` invece di una semplice `category`. Per personalizzare ulteriormente i nomi delle colonne, è possibile modificare gli alias in base alle proprie preferenze. Ad esempio, è possibile utilizzare caratteri di sottolineatura o altri separatori per delimitare i nomi `struct` e i nomi dei campi. 

Ricordarsi di modificare i nomi e i riferimenti `struct` delle colonne in base alla definizione della tabella e ai campi che si desidera inserire nel risultato della query.

```
SELECT 
  firewall_name,
  availability_zone,
  event_timestamp,
  event.timestamp AS event_timestamp,
  event.flow_id AS event_flow_id,
  event.event_type AS event_type,
  event.src_ip AS event_src_ip,
  event.src_port AS event_src_port,
  event.dest_ip AS event_dest_ip,
  event.dest_port AS event_dest_port,
  event.proto AS event_protol,
  event.app_proto AS event_app_proto,
  event.sni AS event_sni,
  event.tls_inspected AS event_tls_inspected,
  event.tls_error.error_message AS event_tls_error_message,
  event.revocation_check.leaf_cert_fpr AS event_revocation_leaf_cert,
  event.revocation_check.status AS event_revocation_check_status,
  event.revocation_check.action AS event_revocation_check_action,
  event.alert.alert_id AS event_alert_alert_id,
  event.alert.alert_type AS event_alert_alert_type,
  event.alert.action AS event_alert_action,
  event.alert.signature_id AS event_alert_signature_id,
  event.alert.rev AS event_alert_rev,
  event.alert.signature AS event_alert_signature,
  event.alert.category AS event_alert_category,
  event.alert.severity AS event_alert_severity,
  event.alert.rule_name AS event_alert_rule_name,
  event.alert.alert_name AS event_alert_alert_name,
  event.alert.alert_severity AS event_alert_alert_severity,
  event.alert.alert_description AS event_alert_alert_description,
  event.alert.file_name AS event_alert_file_name,
  event.alert.file_hash AS event_alert_file_hash,
  event.alert.packet_capture AS event_alert_packet_capture,
  event.alert.reference_links AS event_alert_reference_links,
  event.src_country AS event_src_country,
  event.dest_country AS event_dest_country,
  event.src_hostname AS event_src_hostname,
  event.dest_hostname AS event_dest_hostname,
  event.user_agent AS event_user_agent,
  event.url AS event_url
FROM 
  network_firewall_alert_logs 
WHERE 
  event.alert.severity >= 2
  AND event.tls_inspected = true 
LIMIT 10;
```

# Creare ed eseguire query in una tabella per i log di netflow
<a name="querying-network-firewall-logs-sample-netflow-logs-table"></a>

1. Modificare la seguente istruzione DDL di esempio per renderla conforme alla struttura dei log di netflow. Potrebbe essere necessario aggiornare l'istruzione per includere le colonne per la versione più recente dei log. Per ulteriori informazioni, consulta [Contenuti di un log firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html#firewall-logging-contents) nella *Guida per gli sviluppatori di AWS Network Firewall *.

   ```
   CREATE EXTERNAL TABLE network_firewall_netflow_logs (
     firewall_name string,
     availability_zone string,
     event_timestamp string,
     event struct<
       timestamp:string,
       flow_id:bigint,
       event_type:string,
       src_ip:string,
       src_port:int,
       dest_ip:string,
       dest_port:int,
       proto:string,
       app_proto:string,
       tls_inspected:boolean,
       netflow:struct<
         pkts:int,
         bytes:bigint,
         start:string,
         `end`:string,
         age:int,
         min_ttl:int,
         max_ttl:int,
         tcp_flags:struct<
           syn:boolean,
           fin:boolean,
           rst:boolean,
           psh:boolean,
           ack:boolean,
           urg:boolean
           >
         >
       >
   )
   ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe' 
   LOCATION 's3://amzn-s3-demo-bucket/path_to_netflow_logs_folder/';
   ```

1. Modificare la frase `LOCATION` per specificare la cartella per i log in Amazon S3.

1. Eseguire la query `CREATE TABLE` nell’editor di query della console Athena. Una volta completata la query, Athena registra la tabella `network_firewall_netflow_logs`, rendendo i dati in essa contenuti pronti per le query.

## Query di esempio
<a name="querying-network-firewall-logs-netflow-log-sample-query"></a>

La query di log netflow di esempio in questa sezione filtra gli eventi in cui è stata eseguita l’ispezione TLS.

La query utilizza alias per creare intestazioni di colonna di output che mostrano l’appartenenza della colonna `struct`. Ad esempio, l’intestazione di colonna del campo `event.netflow.bytes` è `event_netflow_bytes` invece di una semplice `bytes`. Per personalizzare ulteriormente i nomi delle colonne, è possibile modificare gli alias in base alle proprie preferenze. Ad esempio, è possibile utilizzare caratteri di sottolineatura o altri separatori per delimitare i nomi `struct` e i nomi dei campi. 

Ricordarsi di modificare i nomi e i riferimenti `struct` delle colonne in base alla definizione della tabella e ai campi che si desidera inserire nel risultato della query.

```
SELECT
  event.src_ip AS event_src_ip,
  event.dest_ip AS event_dest_ip,
  event.proto AS event_proto,
  event.app_proto AS event_app_proto,
  event.tls_inspected AS event_tls_inspected,
  event.netflow.pkts AS event_netflow_pkts,
  event.netflow.bytes AS event_netflow_bytes,
  event.netflow.tcp_flags.syn AS event_netflow_tcp_flags_syn 
FROM network_firewall_netflow_logs 
WHERE event.tls_inspected = true
```

# Eseguire query sui log di Network Load Balancer
<a name="networkloadbalancer-classic-logs"></a>

Utilizzare Athena per analizzare ed elaborare i log di Network Load Balancer. Questi log ricevono informazioni dettagliate sulle richieste Transport Layer Security (TLS) inviate al Network Load Balancer. Puoi utilizzare questi log per analizzare i modelli di traffico e risolvere i problemi che potresti incontrare. 

Prima di analizzare i log di accesso di Network Load Balancer, abilitarli e configurali affinché siano salvati nel bucket Amazon S3 di destinazione. Per ulteriori informazioni e per informazioni su ogni voce del log di accesso a Network Load Balancer, consulta [Log di accesso al Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-access-logs.html).

**Per creare la tabella per i log di Network Load Balancer**

1. Copiare e incollare la seguente istruzione DDL nella console Athena. Controlla la [sintassi ](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-access-logs.html#access-log-file-format)dei record di log di Network Load Balancer. Aggiornare l’istruzione come richiesto per includere le colonne e l’espressione regolare corrispondenti ai propri record di log.

   ```
   CREATE EXTERNAL TABLE IF NOT EXISTS nlb_tls_logs (
               type string,
               version string,
               time string,
               elb string,
               listener_id string,
               client_ip string,
               client_port int,
               target_ip string,
               target_port int,
               tcp_connection_time_ms double,
               tls_handshake_time_ms double,
               received_bytes bigint,
               sent_bytes bigint,
               incoming_tls_alert int,
               cert_arn string,
               certificate_serial string,
               tls_cipher_suite string,
               tls_protocol_version string,
               tls_named_group string,
               domain_name string,
               alpn_fe_protocol string,
               alpn_be_protocol string,
               alpn_client_preference_list string,
               tls_connection_creation_time string
               )
               ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
               WITH SERDEPROPERTIES (
               'serialization.format' = '1',
               'input.regex' = 
               '([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*):([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-0-9]*) ([-0-9]*) ([-0-9]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ?([^ ]*)?( .*)?'
               )
               LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/AWS_account_ID/elasticloadbalancing/region';
   ```

1. Modifica il bucket Amazon S3 `LOCATION` per specificare la destinazione dei tuoi log di Network Load Balancer.

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `nlb_tls_logs`, rendendo i dati in essa contenuti pronti per le query.

## Query di esempio
<a name="query-nlb-example"></a>

Per vedere quante volte viene utilizzato un certificato, utilizzare una query simile a questo esempio:

```
SELECT count(*) AS 
         ct,
         cert_arn
FROM "nlb_tls_logs"
GROUP BY  cert_arn;
```

La query seguente mostra come molti utenti utilizzano una versione di TLS precedente alla 1.3:

```
SELECT tls_protocol_version,
         COUNT(tls_protocol_version) AS 
         num_connections,
         client_ip
FROM "nlb_tls_logs"
WHERE tls_protocol_version < 'tlsv13'
GROUP BY tls_protocol_version, client_ip;
```

Utilizzare la seguente query per identificare le connessioni che richiedono un tempo di handshake TLS lungo:

```
SELECT *
FROM "nlb_tls_logs"
ORDER BY  tls_handshake_time_ms DESC 
LIMIT 10;
```

Utilizzare la seguente query per identificare e contare quali versioni del protocollo TLS e suite di cifratura sono state negoziate negli ultimi 30 giorni.

```
SELECT tls_cipher_suite,
         tls_protocol_version,
         COUNT(*) AS ct
FROM "nlb_tls_logs"
WHERE from_iso8601_timestamp(time) > current_timestamp - interval '30' day
        AND NOT tls_protocol_version = '-'
GROUP BY tls_cipher_suite, tls_protocol_version
ORDER BY ct DESC;
```

# Esguire query sui log di Amazon Route 53 Resolver
<a name="querying-r53-resolver-logs"></a>

Puoi creare tabelle Athena per i log delle query di Amazon Route 53 Resolver ed eseguire query da Athena.

I log delle query del Route 53 Resolver consentono la registrazione delle query DNS eseguite da risorse all'interno di risorse VPC on-premise che utilizzano endpoint Resolver in ingresso, query che utilizzano un endpoint Resolver in uscita per la risoluzione DNS ricorsiva e query che utilizzano regole del firewall DNS di Route 53 Resolver Route per bloccare, consentire o monitorare un elenco di domini. Per ulteriori informazioni, consulta [Log delle query Resolver](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-query-logs.html) nella *Guida per sviluppatori di Amazon Route 53*. Per informazioni su ciascuno dei campi nei log, consulta [Valori visualizzati nei log di query di Resolver](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-query-logs-format.html) nella *Guida per sviluppatori di Amazon Route 53*.

**Topics**
+ [Creare la tabella per i log di query di Resolver](querying-r53-resolver-logs-creating-the-table.md)
+ [Utilizzo della proiezione di partizioni](querying-r53-resolver-logs-partitioning-example.md)
+ [Query di esempio](querying-r53-resolver-logs-example-queries.md)

# Creare la tabella per i log di query di Resolver
<a name="querying-r53-resolver-logs-creating-the-table"></a>

È possibile utilizzare l'editor di query nella console Athena per creare e interrogare una tabella per i log delle query di Route 53 Resolver.

**Per creare ed eseguire query su una tabella Athena per i log delle query di Route 53 Resolver**

1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Nell'editor di query Athena, inserire la seguente istruzione `CREATE TABLE`. Sostituire i valori della clausola `LOCATION` con quelli corrispondenti alla posizione dei log di Resolver nel bucket Amazon S3.

   ```
   CREATE EXTERNAL TABLE r53_rlogs (
     version string,
     account_id string,
     region string,
     vpc_id string,
     query_timestamp string,
     query_name string,
     query_type string,
     query_class
       string,
     rcode string,
     answers array<
       struct<
         Rdata: string,
         Type: string,
         Class: string>
       >,
     srcaddr string,
     srcport int,
     transport string,
     srcids struct<
       instance: string,
       resolver_endpoint: string
       >,
     firewall_rule_action string,
     firewall_rule_group_id string,
     firewall_domain_list_id string
    )
        
   ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
   LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/aws_account_id/vpcdnsquerylogs/{vpc-id}/'
   ```

   Poiché i dati del registro delle query di Resolver sono in formato JSON, l'istruzione CREATE TABLE utilizza una [ SerDelibreria JSON](json-serde.md) per analizzare i dati.
**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 

1. Scegli **Esegui query**. L'istruzione crea una tabella Athena denominata `r53_rlogs` le cui colonne rappresentano ciascuno dei campi nei dati dei log di Resolver.

1. Nell'editor di query della console Athena, eseguire la seguente query per verificare che la tabella sia stata creata.

   ```
   SELECT * FROM "r53_rlogs" LIMIT 10
   ```

# Utilizzo della proiezione di partizioni
<a name="querying-r53-resolver-logs-partitioning-example"></a>

L'esempio seguente mostra una dichiarazione `CREATE TABLE` per i log delle query di Resolver che utilizza la proiezione delle partizioni ed è partizionata per vpc e per data. Per maggiori informazioni sulla proiezione delle partizioni, consulta [Proiezione delle partizioni con Amazon Athena](partition-projection.md).

```
CREATE EXTERNAL TABLE r53_rlogs (
  version string,
  account_id string,
  region string,
  vpc_id string,
  query_timestamp string,
  query_name string,
  query_type string,
  query_class string,
  rcode string,
  answers array<
    struct<
      Rdata: string,
      Type: string,
      Class: string>
    >,
  srcaddr string,
  srcport int,
  transport string,
  srcids struct<
    instance: string,
    resolver_endpoint: string
    >,
  firewall_rule_action string,
  firewall_rule_group_id string,
  firewall_domain_list_id string
)
PARTITIONED BY (
`date` string,
`vpc` 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/route53-query-logging/AWSLogs/aws_account_id/vpcdnsquerylogs/'
TBLPROPERTIES(
'projection.enabled' = 'true',
'projection.vpc.type' = 'enum',
'projection.vpc.values' = 'vpc-6446ae02',
'projection.date.type' = 'date',
'projection.date.range' = '2023/06/26,NOW',
'projection.date.format' = 'yyyy/MM/dd',
'projection.date.interval' = '1',
'projection.date.interval.unit' = 'DAYS',
'storage.location.template' = 's3://amzn-s3-demo-bucket/route53-query-logging/AWSLogs/aws_account_id/vpcdnsquerylogs/${vpc}/${date}/'
)
```

# Query di esempio
<a name="querying-r53-resolver-logs-example-queries"></a>

Gli esempi seguenti mostrano alcune query che è possibile eseguire da Athena nei log delle query di Resolver.

## Esempio 1: log di query in ordine query\$1timestamp decrescente
<a name="querying-r53-resolver-logs-example-1-query-logs-in-descending-query_timestamp-order"></a>

La query seguente visualizza i risultati del log in ordine `query_timestamp` decrescente.

```
SELECT * FROM "r53_rlogs"
ORDER BY query_timestamp DESC
```

## Esempio 2: log di query all'interno dell'ora di inizio e di fine specificata
<a name="querying-r53-resolver-logs-example-2-query-logs-within-specified-start-and-end-times"></a>

Le query riportate di seguito registrano log tra mezzanotte e le 8 del 24 settembre 2020. Sostituisci l'ora di inizio e di fine secondo le tue esigenze.

```
SELECT query_timestamp, srcids.instance, srcaddr, srcport, query_name, rcode
FROM "r53_rlogs"
WHERE (parse_datetime(query_timestamp,'yyyy-MM-dd''T''HH:mm:ss''Z')
     BETWEEN parse_datetime('2020-09-24-00:00:00','yyyy-MM-dd-HH:mm:ss') 
     AND parse_datetime('2020-09-24-00:08:00','yyyy-MM-dd-HH:mm:ss'))
ORDER BY query_timestamp DESC
```

## Esempio 3: log di query basati su un modello di nome query DNS specificato
<a name="querying-r53-resolver-logs-example-3-query-logs-based-on-a-specified-dns-query-name-pattern"></a>

La query seguente seleziona i registri il cui nome della query include la stringa "example.com".

```
SELECT query_timestamp, srcids.instance, srcaddr, srcport, query_name, rcode, answers
FROM "r53_rlogs"
WHERE query_name LIKE '%example.com%'
ORDER BY query_timestamp DESC
```

## Esempio 4: richieste di log di query senza risposta
<a name="querying-r53-resolver-logs-example-4-query-log-requests-with-no-answer"></a>

La query seguente seleziona le voci di log in cui la richiesta non ha ricevuto risposta.

```
SELECT query_timestamp, srcids.instance, srcaddr, srcport, query_name, rcode, answers
FROM "r53_rlogs"
WHERE cardinality(answers) = 0
```

## Esempio 5: log di query con una risposta specifica
<a name="querying-r53-resolver-logs-example-5-query-logs-with-a-specific-answer"></a>

La query seguente mostra i log in cui il valore `answer.Rdata` ha l'indirizzo IP specificato.

```
SELECT query_timestamp, srcids.instance, srcaddr, srcport, query_name, rcode, answer.Rdata
FROM "r53_rlogs"
CROSS JOIN UNNEST(r53_rlogs.answers) as st(answer)
WHERE answer.Rdata='203.0.113.16';
```

# Eseguire query sui log di eventi in Amazon SES
<a name="querying-ses-logs"></a>

Puoi utilizzare Amazon Athena per eseguire query sui registri eventi di [Servizio di e-mail semplice Amazon (Amazon SES)](https://aws.amazon.com/ses/).

Amazon SES è una piattaforma e-mail che offre un metodo comodo e conveniente per inviare e ricevere e-mail usando domini e indirizzi e-mail personali. Puoi monitorare le attività di invio di Amazon SES a un livello granulare utilizzando eventi, parametri e statistiche.

In base alle caratteristiche che definisci, puoi pubblicare eventi Amazon SES su Amazon CloudWatch, [Amazon](https://aws.amazon.com/cloudwatch/) [Data Firehose](https://aws.amazon.com/kinesis/data-firehose/) o Amazon [Simple Notification Service](https://aws.amazon.com/sns/). Dopo aver archiviato le informazioni in Amazon S3, è possibile eseguire query su Amazon Athena. 

Per un esempio di `CREATE TABLE` istruzione Athena per i log di Amazon SES, che include i passaggi su come creare viste e appiattire gli array annidati nei dati dei log degli eventi di Amazon SES, consulta «Fase 3: Utilizzo di Amazon Athena per interrogare i log degli eventi SES» nel post del AWS blog [Analyzing](https://aws.amazon.com/blogs/messaging-and-targeting/analyzing-amazon-ses-event-data-with-aws-analytics-services/) Amazon SES Event Data with Analytics Services. AWS 

# Eseguire query sui log di flusso Amazon VPC
<a name="vpc-flow-logs"></a>

I flussi di log Amazon Virtual Private Cloud acquisiscono informazioni sul traffico IP da e verso le interfacce di rete in un VPC. Utilizza i log per analizzare i modelli di traffico di rete e identificare le minacce e i rischi nella rete VPC.

Per eseguire query nel flusso di log di Amazon VPC, sono disponibili due opzioni:

****
+ Console **Amazon VPC: utilizza la funzionalità di integrazione Athena nella console** Amazon VPC per generare un modello CloudFormation che crei un database Athena, un gruppo di lavoro e una tabella di log di flusso con partizionamento per te. Il modello crea inoltre un set di [query di flusso di log predefinite](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html#predefined-queries) che può essere utilizzato per ottenere informazioni dettagliate sul traffico in transito attraverso il VPC.

  Per ulteriori informazioni su questo approccio, consulta [Eseguire una query dei flussi di log tramite Amazon Athena](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html) nella *Guida per l'utente di Amazon VPC*.
+ **Console Amazon Athena**: crea le tabelle e le query direttamente nella console Athena. Per maggiori informazioni, continua a leggere questa pagina.

Prima di iniziare a eseguire query sui log in Athena, [abilita i log di flusso VPC](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/flow-logs.html) e configurali in modo che possano essere salvati nel bucket Amazon S3. Dopo aver creato i log, lasciali in esecuzione per qualche minuto per raccogliere alcuni dati. I log vengono creati in un formato di compressione GZIP su cui Athena consente di eseguire query direttamente. 

Durante la creazione di un log di flusso, puoi utilizzare un formato personalizzato quando vuoi specificare quali campi restituire nel log di flusso e l'ordine in cui visualizzarli. Per ulteriori informazioni sui record dei log di flusso, consulta [Record log di flusso](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records) nella *Guida per l'utente di Amazon VPC*.

## Considerazioni e limitazioni
<a name="vpc-flow-logs-common-considerations"></a>

Quando si creano tabelle nei flussi di log di Athena per Amazon VPC, tenere in considerazione i seguenti punti:
+ Per impostazione predefinita, in Athena, Parquet accederà alle colonne in base al nome. Per ulteriori informazioni, consulta [Gestire gli aggiornamenti degli schemi](handling-schema-updates-chapter.md).
+ Utilizzare i nomi nei record del flusso di log per i nomi delle colonne in Athena. I nomi delle colonne nello schema Athena devono corrispondere esattamente ai nomi dei campi nel flusso di log Amazon VPC, con le seguenti differenze: 
  + Sostituire i trattini nei nomi dei campi di log di Amazon VPC con i caratteri di sottolineatura nei nomi delle colonne Athena. Per informazioni sui caratteri consentiti per i nomi di database, tabelle e colonne in Athena, consultare [Nomi di tabelle, database e colonne](tables-databases-columns-names.md).
  + Escludere i nomi dei registri del flusso di log che rappresentano in Athena [parole chiave riservate](reserved-words.md), racchiudendoli tra apici retroversi (`). 
+ I log di flusso VPC sono specifici. Account AWS Quando pubblichi i tuoi file di log su Amazon S3, il percorso creato da Amazon VPC in Amazon S3 include l'ID dell' Account AWS che è stato utilizzato per crearli. Per ulteriori informazioni, consulta la sezione relativa alla [pubblicazione di registri di flusso in Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-s3.html) nella *Guida per l'utente di Amazon VPC*.

**Topics**
+ [Considerazioni e limitazioni](#vpc-flow-logs-common-considerations)
+ [Creare una tabella per il flusso di log di Amazon VPC ed eseguire query nella stessa](vpc-flow-logs-create-table-statement.md)
+ [Creare tabelle per il flusso di log in formato Apache Parquet](vpc-flow-logs-parquet.md)
+ [Creare ed eseguire query su una tabella per il flusso di log di Amazon VPC tramite la proiezione delle partizioni](vpc-flow-logs-partition-projection.md)
+ [Creare tabelle per il flusso di log in formato Apache Parquet usando la proiezione di partizione](vpc-flow-logs-partition-projection-parquet-example.md)
+ [Risorse aggiuntive](query-examples-vpc-logs-additional-resources.md)

# Creare una tabella per il flusso di log di Amazon VPC ed eseguire query nella stessa
<a name="vpc-flow-logs-create-table-statement"></a>

La procedura seguente consente di creare una tabella Amazon VPC per il flusso di log di Amazon VPC. Quando crei un log di flusso con un formato personalizzato, crea una tabella con campi che corrispondano a quelli specificati durante la creazione del log di flusso, nello stesso ordine in cui li hai specificati.

**Per creare una tabella Athena per il flusso di log di Amazon VPC**

1. Inserire un'istruzione DDL come la seguente nell'editor di query della console Athena, seguendo le linee guida riportate nella sezione [Considerazioni e limitazioni](vpc-flow-logs.md#vpc-flow-logs-common-considerations). L'istruzione di esempio crea una tabella con le colonne per il flusso di log di Amazon VPC, versioni da 2 a 5, come documentato in [Registri del flusso di log](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records). Se si utilizza un set di colonne o un ordine di colonne diverso, modificare questa istruzione di conseguenza.

   ```
   CREATE EXTERNAL TABLE IF NOT EXISTS `vpc_flow_logs` (
     version int,
     account_id string,
     interface_id string,
     srcaddr string,
     dstaddr string,
     srcport int,
     dstport int,
     protocol bigint,
     packets bigint,
     bytes bigint,
     start bigint,
     `end` bigint,
     action string,
     log_status string,
     vpc_id string,
     subnet_id string,
     instance_id string,
     tcp_flags int,
     type string,
     pkt_srcaddr string,
     pkt_dstaddr string,
     region string,
     az_id string,
     sublocation_type string,
     sublocation_id string,
     pkt_src_aws_service string,
     pkt_dst_aws_service string,
     flow_direction string,
     traffic_path int
   )
   PARTITIONED BY (`date` date)
   ROW FORMAT DELIMITED
   FIELDS TERMINATED BY ' '
   LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/{region_code}/'
   TBLPROPERTIES ("skip.header.line.count"="1");
   ```

   Notare i seguenti punti:
   + La query specifica `ROW FORMAT DELIMITED` e omette di specificare un. SerDe Ciò significa che la query utilizza il metodo [Lazy SerDe Simple per file CSV, TSV e delimitati in modo personalizzato](lazy-simple-serde.md). In questa query, i campi terminano con uno spazio.
   + La clausola `PARTITIONED BY` utilizza il tipo `date`. In questo modo è possibile utilizzare operatori matematici nelle query per selezionare ciò che è più vecchio o più recente rispetto a una determinata data.
**Nota**  
Poiché `date` è una parola chiave riservata nelle istruzioni DDL, questa viene preceduta da caratteri di apice inverso. Per ulteriori informazioni, consulta [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md).
   + Per un log di flusso VPC con un formato personalizzato diverso, modifica i campi in modo che corrispondano a quelli specificati durante la creazione del log di flusso.

1. Modificare `LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/{region_code}/'` perché punti al bucket Amazon S3 che contiene i dati di log.

1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `vpc_flow_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.

1. Creare partizioni per poter leggere i dati, come nella seguente query di esempio. Questa query crea una singola partizione per una data specificata. Sostituire i segnaposto per data e posizione in base alle esigenze. 
**Nota**  
Questa query crea unicamente una singola partizione, per la data specificata. Per automatizzare il processo, utilizzare uno script che esegue questa query e crea partizioni in questo modo per `year/month/day` oppure utilizzare un'istruzione `CREATE TABLE` che specifica la [proiezione delle partizioni](vpc-flow-logs-partition-projection.md).

   ```
   ALTER TABLE vpc_flow_logs
   ADD PARTITION (`date`='YYYY-MM-dd')
   LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/{region_code}/YYYY/MM/dd';
   ```

## Query di esempio per la tabella vpc\$1flow\$1logs
<a name="query-examples-vpc-logs"></a>

Utilizzare l'editor di query nella console Athena per eseguire istruzioni SQL sulla tabella creata. È possibile salvare le query, visualizzare le query precedenti o scaricare i risultati delle query in formato CSV. Negli esempi seguenti, sostituire `vpc_flow_logs` con il nome della tabella. Modificare i valori delle colonne e altre variabili in base alle proprie esigenze.

La query di esempio seguente elenca un massimo di 100 log di flusso per la data specificata.

```
SELECT * 
FROM vpc_flow_logs 
WHERE date = DATE('2020-05-04') 
LIMIT 100;
```

La query seguente elenca tutte le connessioni TCP rifiutate e utilizza la colonna di partizione della data appena creata, `date`, per estrarne il giorno della settimana in cui si verificano questi eventi.

```
SELECT day_of_week(date) AS
  day,
  date,
  interface_id,
  srcaddr,
  action,
  protocol
FROM vpc_flow_logs
WHERE action = 'REJECT' AND protocol = 6
LIMIT 100;
```

Per vedere quale server riceve il numero più elevato di richieste HTTPS, utilizzare la seguente query. Conta il numero di pacchetti ricevuti sulla porta HTTPS 443, li raggruppa in base all'indirizzo IP di destinazione e restituisce i primi 10.

```
SELECT SUM(packets) AS
  packetcount,
  dstaddr
FROM vpc_flow_logs
WHERE dstport = 443 AND date > current_date - interval '7' day
GROUP BY dstaddr
ORDER BY packetcount DESC
LIMIT 10;
```

# Creare tabelle per il flusso di log in formato Apache Parquet
<a name="vpc-flow-logs-parquet"></a>

La procedura seguente consente di creare una tabella Amazon VPC per il flusso di log di Amazon VPC in formato Apache Parquet.

**Per creare una tabella Athena per il flusso di log di Amazon VPC in formato Parquet**

1. Inserire un'istruzione DDL come la seguente nell'editor di query della console Athena, seguendo le linee guida riportate nella sezione [Considerazioni e limitazioni](vpc-flow-logs.md#vpc-flow-logs-common-considerations). L'istruzione di esempio crea una tabella con le colonne per il flusso di log di Amazon VPC, versioni da 2 a 5, come documentato in [Registri del flusso di log](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records) in formato Parquet, partizionato con Hive ogni ora. Se non disponi di partizioni orarie, rimuovi `hour` dalla clausola `PARTITIONED BY`.

   ```
   CREATE EXTERNAL TABLE IF NOT EXISTS vpc_flow_logs_parquet (
     version int,
     account_id string,
     interface_id string,
     srcaddr string,
     dstaddr string,
     srcport int,
     dstport int,
     protocol bigint,
     packets bigint,
     bytes bigint,
     start bigint,
     `end` bigint,
     action string,
     log_status string,
     vpc_id string,
     subnet_id string,
     instance_id string,
     tcp_flags int,
     type string,
     pkt_srcaddr string,
     pkt_dstaddr string,
     region string,
     az_id string,
     sublocation_type string,
     sublocation_id string,
     pkt_src_aws_service string,
     pkt_dst_aws_service string,
     flow_direction string,
     traffic_path int
   )
   PARTITIONED BY (
     `aws-account-id` string,
     `aws-service` string,
     `aws-region` string,
     `year` string, 
     `month` string, 
     `day` string,
     `hour` string
   )
   ROW FORMAT SERDE 
     'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
   STORED AS INPUTFORMAT 
     'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat' 
   OUTPUTFORMAT 
     'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
   LOCATION
     's3://amzn-s3-demo-bucket/prefix/AWSLogs/'
   TBLPROPERTIES (
     'EXTERNAL'='true', 
     'skip.header.line.count'='1'
     )
   ```

1. Modificare `LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/'` perché punti al bucket Amazon S3 che contiene i dati di log.

1. Eseguire la query nella console Athena.

1. Se i dati sono in formato compatibile con Hive, esegui il seguente comando nella console Athena per aggiornare e caricare le partizioni Hive nel metastore. Una volta completata la query, è possibile eseguire query sui dati nella tabella `vpc_flow_logs_parquet`.

   ```
   MSCK REPAIR TABLE vpc_flow_logs_parquet
   ```

   Se non utilizzi dati compatibili con Hive, esegui [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) per caricare le partizioni.

Per ulteriori informazioni sull'utilizzo di Athena per eseguire query sul log di flusso di Amazon VPC in formato Parquet, consulta il post [Optimize performance and reduce costs for network analytics with VPC Flow Logs in Apache Parquet format](https://aws.amazon.com/blogs/big-data/optimize-performance-and-reduce-costs-for-network-analytics-with-vpc-flow-logs-in-apache-parquet-format/) nell'*AWS Big Data Blog*.

# Creare ed eseguire query su una tabella per il flusso di log di Amazon VPC tramite la proiezione delle partizioni
<a name="vpc-flow-logs-partition-projection"></a>

Utilizzare una istruzione `CREATE TABLE` come la seguente per creare una tabella, partizionarla e popolare automaticamente le partizioni utilizzando la [proiezione delle partizioni](partition-projection.md). Sostituire il nome della tabella `test_table_vpclogs` nell'esempio con il nome della propria tabella. Modificare la clausola `LOCATION` per specificare il bucket Amazon S3 che contiene i dati di log di Amazon VPC.

La seguente istruzione `CREATE TABLE` è per il flusso di log VPC fornito in formato di partizionamento in stile non Hive. L'esempio consente l'aggregazione di più account. Se stai centralizzando i log di flusso VPC da più account in un bucket Amazon S3, l'ID dell'account deve essere inserito nel percorso Amazon S3.

```
CREATE EXTERNAL TABLE IF NOT EXISTS test_table_vpclogs (
  version int,
  account_id string,
  interface_id string,
  srcaddr string,
  dstaddr string,
  srcport int,
  dstport int,
  protocol bigint,
  packets bigint,
  bytes bigint,
  start bigint,
  `end` bigint,
  action string,
  log_status string,
  vpc_id string,
  subnet_id string,
  instance_id string,
  tcp_flags int,
  type string,
  pkt_srcaddr string,
  pkt_dstaddr string,
  az_id string,
  sublocation_type string,
  sublocation_id string,
  pkt_src_aws_service string,
  pkt_dst_aws_service string,
  flow_direction string,
  traffic_path int
)
PARTITIONED BY (accid string, region string, day string)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ' '
LOCATION '$LOCATION_OF_LOGS'
TBLPROPERTIES
(
"skip.header.line.count"="1",
"projection.enabled" = "true",
"projection.accid.type" = "enum",
"projection.accid.values" = "$ACCID_1,$ACCID_2",
"projection.region.type" = "enum",
"projection.region.values" = "$REGION_1,$REGION_2,$REGION_3",
"projection.day.type" = "date",
"projection.day.range" = "$START_RANGE,NOW",
"projection.day.format" = "yyyy/MM/dd",
"storage.location.template" = "s3://amzn-s3-demo-bucket/AWSLogs/${accid}/vpcflowlogs/${region}/${day}"
)
```

## Query di esempio per test\$1table\$1vpclogs
<a name="query-examples-vpc-logs-pp"></a>

Nelle seguenti query di esempio viene interrogata la `test_table_vpclogs` creata dall'istruzione `CREATE TABLE` precedente. Sostituire `test_table_vpclogs` nelle query con il nome della propria tabella. Modificare i valori delle colonne e altre variabili in base alle proprie esigenze.

Per restituire le prime 100 voci di log di accesso in ordine cronologico per un determinato periodo di tempo, eseguire una query come la seguente.

```
SELECT *
FROM test_table_vpclogs
WHERE day >= '2021/02/01' AND day < '2021/02/28'
ORDER BY day ASC
LIMIT 100
```

Per visualizzare quale server riceve i dieci pacchetti HTTP principali per un determinato periodo di tempo, eseguire una query come la seguente. La query conta il numero di pacchetti ricevuti sulla porta HTTPS 443, li raggruppa in base all'indirizzo IP di destinazione e restituisce le prime 10 voci principali dalla settimana precedente.

```
SELECT SUM(packets) AS packetcount, 
       dstaddr
FROM test_table_vpclogs
WHERE dstport = 443
  AND day >= '2021/03/01'
  AND day < '2021/03/31'
GROUP BY dstaddr
ORDER BY packetcount DESC
LIMIT 10
```

Per restituire i registri creati durante un determinato periodo di tempo, eseguire una query come la seguente.

```
SELECT interface_id,
       srcaddr,
       action,
       protocol,
       to_iso8601(from_unixtime(start)) AS start_time,
       to_iso8601(from_unixtime("end")) AS end_time
FROM test_table_vpclogs
WHERE DAY >= '2021/04/01'
  AND DAY < '2021/04/30'
```

Per restituire i registri di accesso per un indirizzo IP di origine tra i periodi di tempo specificati, eseguire una query come la seguente.

```
SELECT *
FROM test_table_vpclogs
WHERE srcaddr = '10.117.1.22'
  AND day >= '2021/02/01'
  AND day < '2021/02/28'
```

Per elencare le connessioni TCP rifiutate, eseguire una query come la seguente.

```
SELECT day,
       interface_id,
       srcaddr,
       action,
       protocol
FROM test_table_vpclogs
WHERE action = 'REJECT' AND protocol = 6 AND day >= '2021/02/01' AND day < '2021/02/28'
LIMIT 10
```

Per restituire i registri di accesso per l'intervallo di indirizzi IP che inizia con `10.117`, eseguire una query come la seguente.

```
SELECT *
FROM test_table_vpclogs
WHERE split_part(srcaddr,'.', 1)='10'
  AND split_part(srcaddr,'.', 2) ='117'
```

Per restituire i registri di accesso per un indirizzo IP di destinazione tra i periodi di tempo specificati, eseguire una query come la seguente.

```
SELECT *
FROM test_table_vpclogs
WHERE dstaddr = '10.0.1.14'
  AND day >= '2021/01/01'
  AND day < '2021/01/31'
```

# Creare tabelle per il flusso di log in formato Apache Parquet usando la proiezione di partizione
<a name="vpc-flow-logs-partition-projection-parquet-example"></a>

La seguente istruzione di proiezione della partizione `CREATE TABLE` per i log di flusso VPC è in formato Apache Parquet, non è compatibile con Hive e partizionata per ora e per data anziché per giorno. Sostituire il nome della tabella `test_table_vpclogs_parquet` nell'esempio con il nome della propria tabella. Modificare la clausola `LOCATION` per specificare il bucket Amazon S3 che contiene i dati di log di Amazon VPC.

```
CREATE EXTERNAL TABLE IF NOT EXISTS test_table_vpclogs_parquet (
  version int,
  account_id string,
  interface_id string,
  srcaddr string,
  dstaddr string,
  srcport int,
  dstport int,
  protocol bigint,
  packets bigint,
  bytes bigint,
  start bigint,
  `end` bigint,
  action string,
  log_status string,
  vpc_id string,
  subnet_id string,
  instance_id string,
  tcp_flags int,
  type string,
  pkt_srcaddr string,
  pkt_dstaddr string,
  az_id string,
  sublocation_type string,
  sublocation_id string,
  pkt_src_aws_service string,
  pkt_dst_aws_service string,
  flow_direction string,
  traffic_path int
)
PARTITIONED BY (region string, date string, hour string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/'
TBLPROPERTIES (
"EXTERNAL"="true",
"skip.header.line.count" = "1",
"projection.enabled" = "true",
"projection.region.type" = "enum",
"projection.region.values" = "us-east-1,us-west-2,ap-south-1,eu-west-1",
"projection.date.type" = "date",
"projection.date.range" = "2021/01/01,NOW",
"projection.date.format" = "yyyy/MM/dd",
"projection.hour.type" = "integer",
"projection.hour.range" = "00,23",
"projection.hour.digits" = "2",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/AWSLogs/${account_id}/vpcflowlogs/${region}/${date}/${hour}"
)
```

# Risorse aggiuntive
<a name="query-examples-vpc-logs-additional-resources"></a>

Per ulteriori informazioni sull'utilizzo di Athena per analizzare i log di flusso del VPC, consulta i seguenti articoli del blog sui big data AWS :
+ [Analizza i log di flusso VPC con l'integrazione con Amazon Athena point-and-click](https://aws.amazon.com/blogs/networking-and-content-delivery/analyze-vpc-flow-logs-with-point-and-click-amazon-athena-integration/) 
+ [Analisi dei log di flusso VPC con Amazon Athena e Quick](https://aws.amazon.com/blogs/big-data/analyzing-vpc-flow-logs-using-amazon-athena-and-amazon-quicksight/)
+ [Optimize performance and reduce costs for network analytics with VPC Flow Logs in Apache Parquet format](https://aws.amazon.com/blogs/big-data/optimize-performance-and-reduce-costs-for-network-analytics-with-vpc-flow-logs-in-apache-parquet-format/) (Ottimizzazione delle prestazioni e riduzione dei costi per l'analisi di rete con i log di flusso VPC in formato Apache Parquet)

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

Per ulteriori informazioni sulle query dei log di Amazon S3, consulta i seguenti argomenti:
+ [Come posso analizzare i log di accesso del server Amazon S3 utilizzando Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/analyze-logs-athena/) nel Portale del sapere AWS 
+ [Esecuzione di query sui log di accesso Amazon S3 per le richieste utilizzando Amazon Athena](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-s3-access-logs-to-identify-requests.html#querying-s3-access-logs-for-requests) nella Guida per l'utente di Amazon Simple Storage Service
+ [Utilizzo di AWS CloudTrail per identificare le richieste Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/cloudtrail-request-identification.html) nella Guida per l'utente di Amazon Simple Storage Service