# Consultar logs do AWS service (Serviço da AWS)
<a name="querying-aws-service-logs"></a>

Esta seção inclui vários procedimentos para usar o Amazon Athena para consultar conjuntos de dados conhecidos, como os logs do AWS CloudTrail, Amazon CloudFront, Classic Load Balancer, Application Load Balancer, Network Load Balancer, e os logs de fluxo do Amazon VPC.

As tarefas nesta seção usam o console do Athena, mas você também pode usar outras ferramentas como o [driver JDBC do Athena](connect-with-jdbc.md), a [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/athena/) ou a [referência de API do Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/).

Para obter informações sobre como usar o AWS CloudFormation para criar automaticamente tabelas de log de serviço, partições e consultas de exemplo da AWS service (Serviço da AWS) no Athena, consulte [Automatizar a criação de tabelas de logs de serviço da AWS service (Serviço da AWS) e consultá-las com o Amazon Athena](https://aws.amazon.com/blogs/big-data/automating-aws-service-logs-table-creation-and-querying-them-with-amazon-athena/) no Blog de Big Data da AWS. Para obter informações sobre como usar uma biblioteca Python para o AWS Glue para criar um framework comum de processamento de logs de AWS service (Serviço da AWS) e consultá-los no Athena, consulte [Consulta com facilidade de logs de AWS service (Serviço da AWS) usando o Amazon Athena](https://aws.amazon.com/blogs/big-data/easily-query-aws-service-logs-using-amazon-athena/).

Os tópicos nesta seção pressupõem que você configurou as permissões apropriadas para acessar o Athena e o bucket do Amazon S3 no qual os dados a serem consultados devem residir. Para ter mais informações, consulte [Acesso de configuração, administrativo e programático](setting-up.md) e [Conceitos básicos](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)

# Consultar logs do Application Load Balancer
<a name="application-load-balancer-logs"></a>

O Application Load Balancer é uma opção de balanceamento de carga do Elastic Load Balancing que habilita a distribuição de tráfego em uma implantação de microsserviços usando contêineres. Consultar logs do Application Load Balancer permite consultar a origem do tráfego, a latência e os bytes transferidos de e para instâncias do Elastic Load Balancing e aplicativos de backend. Para obter mais informações, consulte [Logs de acesso para seu Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html) e [Logs de conexão para seu Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html) no *Guia do usuário para Application Load Balancers*.

## Pré-requisitos
<a name="application-load-balancer-logs-prerequisites"></a>
+ Habilite o [registro de acesso em log](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html) ou [registro de conexão em log](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html) para permitir que os logs do Application Load Balancer sejam salvos no seu bucket do Amazon S3.
+ Um banco de dados para conter a tabela que você criará para o Athena. Para criar um banco de dados, é possível usar o Athena ou o console do AWS Glue. Para obter mais informações, consulte [Criar bancos de dados no Athena](creating-databases.md) neste guia ou [Trabalhar com banco de dados no console do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-databases.html), no *Guia do desenvolvedor do AWS Glue*. 

**Topics**
+ [Pré-requisitos](#application-load-balancer-logs-prerequisites)
+ [Criar a tabela para logs de acesso do ALB](create-alb-access-logs-table.md)
+ [Criar a tabela para logs de acesso do ALB no Athena com uso da projeção de partições](create-alb-access-logs-table-partition-projection.md)
+ [Exemplos de consultas para logs de acesso do ALB](query-alb-access-logs-examples.md)
+ [Criar a tabela para logs de conexão do ALB](create-alb-connection-logs-table.md)
+ [Criar a tabela para logs de conexão do ALB no Athena com uso da projeção de partições](create-alb-connection-logs-table-partition-projection.md)
+ [Exemplo de consultas para logs de conexão do ALB](query-alb-connection-logs-examples.md)
+ [Recursos adicionais](application-load-balancer-logs-additional-resources.md)

# Criar a tabela para logs de acesso do ALB
<a name="create-alb-access-logs-table"></a>

1. Copie e cole a declaração `CREATE TABLE` a seguir em um editor de consulta no console do Athena e modifique-a conforme necessário para seus próprios requisitos de entrada de log. Para obter mais informações sobre os conceitos básicos do Athena, consulte [Conceitos básicos](getting-started.md). Substitua o caminho na cláusula `LOCATION` pela localização da pasta de log de acesso do Amazon S3. Para obter mais informações sobre o local do arquivo de log de acesso, consulte [Arquivos de log de acesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-file-format) no *Guia do usuário para Application Load Balancers*.

   Para obter informações sobre cada campo do arquivo de log, consulte [Entradas do log de acesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-entry-format) no *Guia do usuário para Application Load Balancers*.
**nota**  
A declaração de exemplo `CREATE TABLE` a seguir inclui as colunas `classification`, `classification_reason` e `conn_trace_id` (“ID de rastreabilidade” ou TID) adicionadas recentemente. Para criar uma tabela dos logs de acesso do Application Load Balancer que não contenham essas entradas, remova as colunas correspondentes da instrução `CREATE TABLE` e modifique a expressão regex de acordo. 

   ```
   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**  
Sugerimos que o padrão *`?( .*)?`* no final do parâmetro `input.regex` permaneça sempre em vigor para lidar com futuras entradas de registro, caso novos campos de log do ALB sejam adicionados. 

1. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `alb_access_logs`, preparando os dados dela para você fazer as consultas.

# Criar a tabela para logs de acesso do ALB no Athena com uso da projeção de partições
<a name="create-alb-access-logs-table-partition-projection"></a>

Como os logs de acesso do ALB têm uma estrutura conhecida com um esquema de partição que você pode especificar antecipadamente, é possível reduzir o runtime das consultas e automatizar o gerenciamento de partições usando o atributo de projeção de partições do Athena. A projeção de partições adiciona automaticamente novas partições à medida que os dados são adicionados. Isso elimina a necessidade de adicionar manualmente as partições usando `ALTER TABLE ADD PARTITION`. 

O exemplo de instrução `CREATE TABLE` a seguir usa automaticamente a projeção de partições com base em logs de acesso do ALB a partir de uma data especificada até o dia atual para uma única região da AWS. A instrução é baseada no exemplo da seção anterior, mas adiciona as cláusulas `PARTITIONED BY` e `TBLPROPERTIES` para habilitar a projeção de partições. Nas cláusulas `LOCATION` e `storage.location.template`, substitua os espaços reservados pelos valores que identificam o local do bucket do Amazon S3 dos seus logs de acesso do ABL. Para obter mais informações sobre o local do arquivo de log de acesso, consulte [Arquivos de log de acesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-file-format) no *Guia do usuário para Application Load Balancers*. Em ‭`projection.day.range`‬, substitua ‭‭*01‭*‬/‭*01‭*‬/*2022* pela data de início que você deseja usar. Depois que você executar a consulta com êxito, poderá consultar a tabela. Você não precisa executar `ALTER TABLE ADD PARTITION` para carregar as partições. Para obter informações sobre cada campo do arquivo de log, consulte [Entradas de log de acesso](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}"
            )
```

Para obter mais informações sobre projeção de partições, consulte [Usar projeção de partições com o Amazon Athena](partition-projection.md).

**nota**  
Sugerimos que o padrão *?( .\$1)?* no final do parâmetro `input.regex` permaneça sempre aplicado para lidar com futuras entradas de log, caso novos campos de log do ALB sejam adicionados. 

# Exemplos de consultas para logs de acesso do ALB
<a name="query-alb-access-logs-examples"></a>

A consulta a seguir conta o número de solicitações HTTP GET recebidas pelo load balancer agrupadas pelo endereço IP do cliente:

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

Outra consulta mostra os URLs visitados por usuários do navegador Safari:

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

A consulta a seguir mostra registros que têm valores de código de status ELB maiores ou iguais a 500.

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

O exemplo a seguir mostra como analisar os registros por `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;
```

O exemplo a seguir consulta a tabela que usa projeção de partição para todos os logs de acesso do ALB a partir do dia especificado.

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

# Criar a tabela para logs de conexão do ALB
<a name="create-alb-connection-logs-table"></a>

1. Copie e cole o exemplo de declaração `CREATE TABLE` a seguir em um editor de consulta no console do Athena e modifique-a conforme necessário para seus próprios requisitos de entrada de log. Para obter mais informações sobre os conceitos básicos do Athena, consulte [Conceitos básicos](getting-started.md). Substitua o caminho na cláusula `LOCATION` pela localização da pasta de log de conexão do Amazon S3. Para obter mais informações sobre o local do arquivo de log de conexão, consulte [Arquivos de log de conexão](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-file-format) no *Guia do usuário para Application Load Balancers*. Para obter informações sobre cada campo do arquivo de log, consulte [Entradas de log de conexão](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. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `alb_connection_logs`, preparando os dados dela para você fazer as consultas.

# Criar a tabela para logs de conexão do ALB no Athena com uso da projeção de partições
<a name="create-alb-connection-logs-table-partition-projection"></a>

Como os logs de conexão do ALB têm uma estrutura conhecida com um esquema de partição que você pode especificar antecipadamente, é possível reduzir o runtime das consultas e automatizar o gerenciamento de partições usando o atributo de projeção de partições do Athena. A projeção de partições adiciona automaticamente novas partições à medida que os dados são adicionados. Isso elimina a necessidade de adicionar manualmente as partições usando `ALTER TABLE ADD PARTITION`. 

O exemplo de instrução `CREATE TABLE` a seguir usa automaticamente a projeção de partições com base em logs de conexão do ALB a partir de uma data especificada até o dia atual para uma única região da AWS. A instrução é baseada no exemplo da seção anterior, mas adiciona as cláusulas `PARTITIONED BY` e `TBLPROPERTIES` para habilitar a projeção de partições. Nas cláusulas `LOCATION` e `storage.location.template`, substitua os espaços reservados pelos valores que identificam o local do bucket do Amazon S3 dos seus logs de conexão do ABL. Para obter mais informações sobre o local do arquivo de log de conexão, consulte [Arquivos de log de conexão](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-file-format) no *Guia do usuário para Application Load Balancers*. Em ‭`projection.day.range`‬, substitua ‭*01‭*‬/‭*01‭*/‬*2023* pela data de início que você deseja usar. Depois que você executar a consulta com êxito, poderá consultar a tabela. Você não precisa executar `ALTER TABLE ADD PARTITION` para carregar as partições. Para obter informações sobre cada campo do arquivo de log, consulte [Entradas de log de conexão](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}"
            )
```

Para obter mais informações sobre projeção de partições, consulte [Usar projeção de partições com o Amazon Athena](partition-projection.md).

# Exemplo de consultas para logs de conexão do ALB
<a name="query-alb-connection-logs-examples"></a>

A consulta a seguir conta as ocorrências nas quais o valor de `tls_verify_status` não foi `'Success'`, agrupadas por endereço IP do cliente:

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

A consulta a seguir pesquisa ocorrências nas quais o valor de `tls_handshake_latency` foi superior a 2 segundos no intervalo de tempo especificado:

```
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);
```

# Recursos adicionais
<a name="application-load-balancer-logs-additional-resources"></a>

Para obter mais informações sobre o uso de logs do ALB, consulte os recursos a seguir.
+ [Como analisar os logs de acesso do meu Application Load Balancer usando o Amazon Athena](https://repost.aws/knowledge-center/athena-analyze-access-logs) no *Centro de Conhecimentos da AWS*.
+ Para obter informações sobre códigos de status HTTP do Elastic Load Balancing, consulte [Solução de problemas em Application Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-troubleshooting.html) no *Guia do usuário para Application Load Balancers*.
+ [Catalogue e analise os logs do Application Load Balancer com mais eficiência com classificadores personalizados AWS Glue 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/) no *Blog de Big Data da AWS*.

# Consulta a logs do Classic Load Balancer
<a name="elasticloadbalancer-classic-logs"></a>

Consulte os logs do Classic Load Balancer para analisar e saber os padrões do tráfego que entra e sai das instâncias e das aplicações de backend do Elastic Load Balancing. Você pode ver a origem do tráfego, da latência e dos bytes que foram transferidos.

Antes de analisar os logs do Elastic Load Balancing, configure-os para que sejam salvos no bucket de destino do Amazon S3. Para obter mais informações, consulte [Habilitar os logs de acesso do seu Classic Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-access-logs.html).

**Para criar a tabela de logs do Elastic Load Balancing**

1. Copie e cole a instrução DDL a seguir no console do Athena. Verifique a [sintaxe ](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/access-log-collection.html#access-log-entry-format) dos registros de log do Elastic Load Balancing. Pode ser necessário atualizar a consulta a seguir para incluir as colunas e a sintaxe Regex para a versão mais recente do registro. 

   ```
   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. Modifique o bucket `LOCATION` do Amazon S3 para especificar o destino dos logs do Elastic Load Balancing.

1. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `elb_logs`, preparando os dados dela para as consultas. Para obter mais informações, consulte [Consultas de exemplo](#query-elb-classic-example).

## Consultas de exemplo
<a name="query-elb-classic-example"></a>

Use uma consulta semelhante à consulta do exemplo a seguir. Ele lista os servidores de aplicativos de backend que retornaram um código de resposta de erro `4XX` ou `5XX`. Use o operador `LIMIT` para limitar o número de logs a serem consultados por vez.

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

Use uma consulta subsequente para somar o tempo de resposta de todas as transações agrupadas por endereço IP de backend e nome da instância do 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;
```

Para obter mais informações, consulte [Analyzing data in S3 using Athena](https://aws.amazon.com/blogs/big-data/analyzing-data-in-s3-using-amazon-athena/) (Analisar dados no S3 usando o Athena).

# Consultar logs do Amazon CloudFront
<a name="cloudfront-logs"></a>

Você pode configurar o CDN do Amazon CloudFront para exportar os logs de acesso de distribuição da Web para o Amazon Simple Storage Service. Use esses logs para explorar os padrões de navegação dos usuários nas propriedades da Web processadas pelo CloudFront.

Antes de começar a consultar os logs, habilite o log de acesso de distribuições da Web de acordo com a sua distribuição preferida do CloudFront. Para obter informações, consulte [Logs de acesso](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html) no *Guia do desenvolvedor do Amazon CloudFront*. Anote o bucket do Amazon S3 no qual salva esses logs.

**Topics**
+ [Criação de uma tabela para os logs padrão do CloudFront (legado)](create-cloudfront-table-standard-logs.md)
+ [Criação de uma tabela para os logs do CloudFront no Athena usando particionamento manual com JSON](create-cloudfront-table-manual-json.md)
+ [Criação de uma tabela para os logs do CloudFront no Athena usando particionamento manual com Parquet](create-cloudfront-table-manual-parquet.md)
+ [Criação de uma tabela para os logs do CloudFront no Athena usando projeção de particionamento com JSON](create-cloudfront-table-partition-json.md)
+ [Criação de uma tabela para os logs do CloudFront no Athena usando projeção de particionamento com Parquet](create-cloudfront-table-partition-parquet.md)
+ [Criar uma tabela para logs em tempo real do CloudFront](create-cloudfront-table-real-time-logs.md)
+ [Recursos adicionais](cloudfront-logs-additional-resources.md)

# Criação de uma tabela para os logs padrão do CloudFront (legado)
<a name="create-cloudfront-table-standard-logs"></a>

**nota**  
O procedimento a seguir funciona para os logs de acesso de distribuição da Web no CloudFront. Ele não se aplica a logs de streaming de distribuições RTMP.

**Para criar uma tabela para campos de arquivo de log padrão do CloudFront**

1. Copie e cole o exemplo de instrução DDL a seguir no editor de consultas no console do Athena. O exemplo de instrução usa os campos do arquivo de log documentados na seção [Campos de arquivo de log padrão](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) do *Guia do usuário do Amazon CloudFront.* Modifique o `LOCATION` para o bucket do Amazon S3 que armazena seus logs. Para obter informações sobre como usar o editor de consultas, acesse [Conceitos básicos](getting-started.md).

   Essa consulta especifica `ROW FORMAT DELIMITED` e `FIELDS TERMINATED BY '\t'` para indicar que os campos são delimitados por caracteres de tabulação. Para `ROW FORMAT DELIMITED`, o Athena usa o [LazySimpleSerDe](lazy-simple-serde.md) por padrão. A coluna `date` é escapada com acentos graves (`) porque se trata de uma palavra reservada no Athena. Para mais informações, consulte [Escapar palavras-chave reservadas em consultas](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. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `cloudfront_standard_logs`, preparando os dados dela para você fazer as consultas.

## Consultas de exemplo
<a name="query-examples-cloudfront-logs"></a>

A consulta a seguir adiciona o número de bytes processados pelo CloudFront entre 9 e 11 de junho de 2018. Coloque o nome da coluna de data entre aspas duplas porque se trata de uma palavra reservada.

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

Para eliminar linhas duplicadas (por exemplo, linhas vazias duplicadas) dos resultados da consulta, é possível usar a instrução `SELECT DISTINCT`, conforme o exemplo a seguir. 

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

# Criação de uma tabela para os logs do CloudFront no Athena usando particionamento manual com JSON
<a name="create-cloudfront-table-manual-json"></a>

**Para criar uma tabela para os campos do arquivo de log padrão do CloudFront usando o formato JSON**

1. Copie e cole o exemplo de instrução DDL a seguir no editor de consultas no console do Athena. O exemplo de instrução usa os campos do arquivo de log documentados na seção [Campos de arquivo de log padrão](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) do *Guia do usuário do Amazon CloudFront.* Modifique o `LOCATION` para o bucket do Amazon S3 que armazena seus logs. 

   Essa consulta usa o OpenX JSON SerDe com as propriedades de SerDe apresentadas a seguir para realizar a leitura dos campos em JSON corretamente no 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. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `cf_logs_manual_partition_json`, preparando os dados dela para você fazer as consultas.

## Consultas de exemplo
<a name="query-examples-cloudfront-logs-manual-json"></a>

A consulta apresentada a seguir soma a quantidade de bytes fornecidos pelo CloudFront no dia 15 de janeiro de 2025.

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

Para eliminar linhas duplicadas (por exemplo, linhas vazias duplicadas) dos resultados da consulta, é possível usar a instrução `SELECT DISTINCT`, conforme o exemplo a seguir. 

```
SELECT DISTINCT * FROM cf_logs_manual_partition_json
```

# Criação de uma tabela para os logs do CloudFront no Athena usando particionamento manual com Parquet
<a name="create-cloudfront-table-manual-parquet"></a>

**Para criar uma tabela para os campos do arquivo de log padrão do CloudFront usando o formato Parquet**

1. Copie e cole o exemplo de instrução DDL a seguir no editor de consultas no console do Athena. O exemplo de instrução usa os campos do arquivo de log documentados na seção [Campos de arquivo de log padrão](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) do *Guia do usuário do Amazon CloudFront.* 

   Essa consulta usa o ParquetHiveSerDe com as propriedades de SerDe apresentadas a seguir para realizar a leitura dos campos em Parquet corretamente no 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. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `cf_logs_manual_partition_parquet`, preparando os dados dela para você fazer as consultas.

## Consultas de exemplo
<a name="query-examples-cloudfront-logs-manual-parquet"></a>

A consulta apresentada a seguir soma a quantidade de bytes fornecidos pelo CloudFront no dia 19 de janeiro de 2025.

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

Para eliminar linhas duplicadas (por exemplo, linhas vazias duplicadas) dos resultados da consulta, é possível usar a instrução `SELECT DISTINCT`, conforme o exemplo a seguir. 

```
SELECT DISTINCT * FROM cf_logs_manual_partition_parquet
```

# Criação de uma tabela para os logs do CloudFront no Athena usando projeção de particionamento com JSON
<a name="create-cloudfront-table-partition-json"></a>

Você pode reduzir o runtime da consulta e automatizar o gerenciamento de particionamento com o recurso de projeção de particionamento do Athena. A projeção de partições adiciona automaticamente novas partições à medida que os dados são adicionados. Isso elimina a necessidade de adicionar manualmente as partições usando `ALTER TABLE ADD PARTITION`.

A instrução CREATE TABLE, apresentada como exemplo a seguir, usa automaticamente a projeção de particionamento nos logs do CloudFront usando uma distribuição do CloudFront especificada até o momento, para uma única Região da AWS. Depois que você executar a consulta com êxito, poderá consultar a tabela.

```
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}/')
```

A seguir, apresentamos algumas considerações sobre as propriedades usadas no exemplo anterior.
+ **Nome da tabela**: o nome da tabela, *`cloudfront_logs_pp`*, pode ser alterado. Você pode alterá-lo para qualquer nome de sua preferência.
+ **Localização**: Altere `s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/` para direcionar para o seu bucket do Amazon S3.
+ **IDs de distribuição**: para `projection.distributionid.values`, você pode especificar vários IDs de distribuição, separando-os por vírgulas. Por exemplo, *<distributionID1>*, *<distributionID2>*.
+ **Intervalo de anos**: em `projection.year.range`, você pode definir o intervalo de anos com base nos seus dados. Por exemplo, você pode ajustá-lo para qualquer período, como 2025 e *2025*, *2026*.
**nota**  
Incluir partições vazias, como aquelas para datas futuras (por exemplo, 2025 a 2040), pode impactar a performance das consultas. No entanto, a projeção de partições foi projetada para lidar efetivamente com datas futuras. Para manter uma performance ideal, garanta que as partições sejam gerenciadas de forma estratégica e evite criar partições vazias excessivas sempre que possível.
+ **Modelo de local de armazenamento**: Você deve garantir que o modelo `storage.location.template` seja atualizado corretamente com base na estrutura de particionamento do CloudFront e no caminho do S3 apresentados a seguir.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/create-cloudfront-table-partition-json.html)

  Após confirmar que a estrutura de particionamento do CloudFront e a estrutura do S3 correspondem aos padrões necessários, atualize o modelo `storage.location.template` da seguinte forma:

  ```
  'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account_id/CloudFront/${distributionid}/folder2/${year}/${month}/${day}/${hour}/folder3/'
  ```
**nota**  
A configuração adequada do modelo `storage.location.template` é essencial para assegurar o armazenamento e a recuperação adequados dos dados.

# Criação de uma tabela para os logs do CloudFront no Athena usando projeção de particionamento com Parquet
<a name="create-cloudfront-table-partition-parquet"></a>

A instrução CREATE TABLE, apresentada como exemplo a seguir, usa automaticamente a projeção de particionamento nos logs do CloudFront em Parquet usando uma distribuição do CloudFront especificada até o momento, para uma única Região da AWS. Depois que você executar a consulta com êxito, poderá consultar a tabela.

```
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}/')
```

A seguir, apresentamos algumas considerações sobre as propriedades usadas no exemplo anterior.
+ **Nome da tabela**: o nome da tabela, *`cloudfront_logs_pp`*, pode ser alterado. Você pode alterá-lo para qualquer nome de sua preferência.
+ **Localização**: Altere `s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/` para direcionar para o seu bucket do Amazon S3.
+ **IDs de distribuição**: para `projection.distributionid.values`, você pode especificar vários IDs de distribuição, separando-os por vírgulas. Por exemplo, *<distributionID1>*, *<distributionID2>*.
+ **Intervalo de anos**: em `projection.year.range`, você pode definir o intervalo de anos com base nos seus dados. Por exemplo, você pode ajustá-lo para qualquer período, como *2025* e *2026*.
**nota**  
Incluir partições vazias, como aquelas para datas futuras (por exemplo, 2025 a 2040), pode impactar a performance das consultas. No entanto, a projeção de partições foi projetada para lidar efetivamente com datas futuras. Para manter uma performance ideal, garanta que as partições sejam gerenciadas de forma estratégica e evite criar partições vazias excessivas sempre que possível.
+ **Modelo de local de armazenamento**: Você deve garantir que o modelo `storage.location.template` seja atualizado corretamente com base na estrutura de particionamento do CloudFront e no caminho do S3 apresentados a seguir.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/create-cloudfront-table-partition-parquet.html)

  Após confirmar que a estrutura de particionamento do CloudFront e a estrutura do S3 correspondem aos padrões necessários, atualize o modelo `storage.location.template` da seguinte forma:

  ```
  'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account_id/CloudFront/${distributionid}/folder2/${year}/${month}/${day}/${hour}/folder3/'
  ```
**nota**  
A configuração adequada do modelo `storage.location.template` é essencial para assegurar o armazenamento e a recuperação adequados dos dados.

# Criar uma tabela para logs em tempo real do CloudFront
<a name="create-cloudfront-table-real-time-logs"></a>

**Para criar uma tabela para campos de arquivo de log em tempo real do CloudFront**

1. Copie e cole o exemplo de instrução DDL a seguir no editor de consultas no console do Athena. O exemplo de instrução usa os campos do arquivo de log documentados na seção [Logs em tempo real](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/real-time-logs.html) do *Guia do usuário do Amazon CloudFront*. Modifique o `LOCATION` para o bucket do Amazon S3 que armazena seus logs. Para obter informações sobre como usar o editor de consultas, acesse [Conceitos básicos](getting-started.md).

   Essa consulta especifica `ROW FORMAT DELIMITED` e `FIELDS TERMINATED BY '\t'` para indicar que os campos são delimitados por caracteres de tabulação. Para `ROW FORMAT DELIMITED`, o Athena usa o [LazySimpleSerDe](lazy-simple-serde.md) por padrão. A coluna `timestamp` é escapada com acentos graves (`) porque se trata de uma palavra reservada no Athena. Para mais informações, consulte [Escapar palavras-chave reservadas em consultas](reserved-words.md).

   O exemplo a seguir contém todos os campos disponíveis. Você pode comentar ou remover campos que não sejam necessários.

   ```
   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. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `cloudfront_real_time_logs`, preparando os dados dela para você fazer as consultas.

# Recursos adicionais
<a name="cloudfront-logs-additional-resources"></a>

Para obter mais informações sobre como usar o Athena para consultar os logs do CloudFront, leia as publicações do [blog sobre big data da AWS](https://aws.amazon.com/blogs/big-data/) a seguir.

[Consulte facilmente os logs de AWS service (Serviço da AWS) usando o Amazon Athena](https://aws.amazon.com/blogs/big-data/easily-query-aws-service-logs-using-amazon-athena/) de 29 de maio de 2019 (em inglês).

[Analise seus logs de acesso do Amazon CloudFront em grande escala](https://aws.amazon.com/blogs/big-data/analyze-your-amazon-cloudfront-access-logs-at-scale/) (21 de dezembro de 2018).

[Construa uma arquitetura serverless para analisar os logs de acesso do Amazon CloudFront usando AWS Lambda, Amazon Athena e o Amazon Managed Service for Apache Flink](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/) (26 de maio de 2017).

# Consultar logs do AWS CloudTrail
<a name="cloudtrail-logs"></a>

O AWS CloudTrail é um serviço que registra chamadas de API da AWS e eventos de contas da Amazon Web Services. 

Os logs do CloudTrail incluem detalhes sobre todas as chamadas de API feitas para seus Serviços da AWS, incluindo o console. O CloudTrail gera arquivos de log criptografados e os armazena no Amazon S3. Para saber mais, consulte o [Guia do usuário do AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html). 

**nota**  
Se você quiser realizar consultas SQL nas informações de eventos do CloudTrail entre contas, regiões e datas, considere usar o CloudTrail Lake. O CloudTrail Lake é uma alternativa da AWS à criação de trilhas que agregam informações de uma empresa em um único armazenamento pesquisável de dados de eventos. Em vez de usar o armazenamento de bucket do Amazon S3, ele armazena eventos em um data lake, o que permite consultas mais avançadas e rápidas. Você pode usá-lo para criar consultas SQL que pesquisem eventos em organizações, regiões e em períodos temporais personalizados. Como você executa consultas do CloudTrail Lake diretamente no console do CloudTrail, o uso do CloudTrail Lake não requer o Athena. Para obter mais informações, consulte a Documentação do [CloudTrail Lake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html).

O uso do Athena com os logs do CloudTrail é uma ótima maneira de melhorar a análise das atividades da AWS service (Serviço da AWS). Por exemplo, é possível usar consultas para identificar tendências e isolar ainda mais a atividade por atributos, como endereço IP de origem ou usuário.

Uma aplicação comum é usar os logs do CloudTrail para analisar a segurança e a compatibilidade das atividades operacionais. Para obter um exemplo detalhado, consulte a publicação no Blog de Big Data da AWS, [Análise de segurança, conformidade e atividades operacionais usando o AWS CloudTrail e o Amazon Athena](https://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/).

Você pode usar o Athena para consultar esses arquivos de log diretamente no Amazon S3 especificando o `LOCATION` dos arquivos de log. É possível fazer isso de duas formas:
+ Criando tabelas para arquivos de log do CloudTrail diretamente no console do CloudTrail.
+ Criando tabelas manualmente para arquivos de log do CloudTrail no console do Athena.

**Topics**
+ [Noções básicas de logs do CloudTrail e tabelas do Athena](create-cloudtrail-table-understanding.md)
+ [Usar o console do CloudTrail para criar uma tabela do Athena com logs do CloudTrail](create-cloudtrail-table-ct.md)
+ [Criar uma tabela de logs do CloudTrail no Athena usando particionamento manual](create-cloudtrail-table.md)
+ [Criar uma tabela para uma trilha em toda a organização usando particionamento manual](create-cloudtrail-table-org-wide-trail.md)
+ [Criar a tabela para logs do CloudTrail no Athena usando a projeção de partições](create-cloudtrail-table-partition-projection.md)
+ [Exemplo de consultas de log do CloudTrail](query-examples-cloudtrail-logs.md)

# Noções básicas de logs do CloudTrail e tabelas do Athena
<a name="create-cloudtrail-table-understanding"></a>

Antes de começar a criar tabelas, você deve conhecer melhor o CloudTrail e saber como ele armazena os dados. Isso pode ajudar a criar as tabelas necessárias, tanto pelo console do CloudTrail quanto pelo Athena.

O CloudTrail salva logs como arquivos de texto JSON no formato compactado gzip (`*.json.gz`). O local dos arquivos de log depende de como você configura as trilhas, da Região da AWS ou das regiões onde você está registrando, além de outros fatores. 

Para obter mais informações de onde os logs são armazenados, da estrutura JSON e do conteúdo do arquivo de registro, consulte os seguintes tópicos no [Manual do usuário do AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html):
+  [Encontrar os arquivos de log do CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-find-log-files.html) 
+  [Exemplos de arquivos de log do CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-log-file-examples.html) 
+  [Conteúdo do registro do CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html)
+  [Referência de eventos do CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference.html) 

Para coletar e salvar os logs no Amazon S3, habilite o CloudTrail no Console de gerenciamento da AWS. Para obter mais informações, consulte [Criar uma trilha](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html) no *Guia do usuário do AWS CloudTrail*.

# Usar o console do CloudTrail para criar uma tabela do Athena com logs do CloudTrail
<a name="create-cloudtrail-table-ct"></a>

Você pode criar uma tabela do Athena não particionada para consultar logs do CloudTrail diretamente no console do CloudTrail. A criação de uma tabela do Athena pelo console do CloudTrail requer que você esteja conectado com um perfil que tenha permissões suficientes para criar tabelas no Athena.

**nota**  
Não é possível usar o console do CloudTrail para criar uma tabela do Athena para logs de trilha da organização. Em vez disso, crie a tabela manualmente usando o console do Athena para que você possa especificar o local correto de armazenamento. Para obter informações sobre trilhas de organização, consulte [Criar uma trilha para uma organização](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/creating-trail-organization.html) no *Manual do usuário do AWS CloudTrail*.
+ Para obter informações sobre como configurar permissões para o Athena, consulte [Acesso de configuração, administrativo e programático](setting-up.md).
+ Para obter informações sobre como criar uma tabela com partições, consulte [Criar uma tabela de logs do CloudTrail no Athena usando particionamento manual](create-cloudtrail-table.md).

**Para criar uma tabela do Athena para uma trilha do CloudTrail no console do CloudTrail**

1. Abra o console do CloudTrail em [https://console.aws.amazon.com/cloudtrail/](https://console.aws.amazon.com/cloudtrail/).

1. No painel de navegação, selecione **Event history (Histórico de eventos)**. 

1. Escolha **Create Athena table** (Criar tabela do Athena).  
![\[Escolher Create Athena table\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/cloudtrail-logs-create-athena-table.png)

1. Em **Storage location** (Local de armazenamento), use a seta para baixo para selecionar o bucket do Amazon S3 onde os arquivos de log estão armazenados para a trilha que será consultada.
**nota**  
Para localizar o nome do bucket associado a uma trilha, escolha **Trails** (Trilhas) no painel de navegação do CloudTrail e visualize a coluna **S3 bucket** (Bucket do S3) da trilha. Para ver o local do bucket do Amazon S3, escolha o link do bucket na coluna **S3 bucket** (Bucket do S3). O console do Amazon S3 é aberto no local do bucket do CloudTrail. 

1. Escolha **Criar tabela**. A tabela é criada com um nome padrão que inclui o nome do bucket do Amazon S3.

# Criar uma tabela de logs do CloudTrail no Athena usando particionamento manual
<a name="create-cloudtrail-table"></a>

É possível criar manualmente tabelas de arquivos de log do CloudTrail no console do Athena e executar consultas no Athena.

**Para criar uma tabela do Athena para uma trilha do CloudTrail no console do Athena**

1. Copie e cole a instrução DDL a seguir em um editor de consultas do console do Athena e modifique-a de acordo com seus requisitos. Observe que, como os arquivos de log do CloudTrail não são um rastreamento de pilha ordenada de chamadas de API públicas, os campos dos arquivos de log não aparecem em nenhuma ordem específica.

   ```
   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**  
Sugerimos usar o `org.apache.hive.hcatalog.data.JsonSerDe` exibido no exemplo. Embora exista um `com.amazon.emr.hive.serde.CloudTrailSerde`, no momento ele não processa alguns dos campos mais recentes do CloudTrail. 

1. (Opcional) Remova quaisquer campos não obrigatórios para a tabela. Se for necessário ler somente um determinado conjunto de colunas, sua definição de tabela poderá excluir as outras colunas.

1. Modifique `s3://amzn-s3-demo-bucket/AWSLogs/Account_ID/` para apontar para o bucket do Amazon S3 que contém os dados de log que você deseja consultar. O exemplo usa um valor `LOCATION` de logs para uma determinada conta, mas você pode usar o grau de especificidade adequado ao aplicativo. Por exemplo:
   + Para analisar dados de várias contas, você pode reverter o especificador `LOCATION` para indicar todos os `AWSLogs` usando `LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/'`.
   + Para analisar dados de uma data, conta e região específica, use `LOCATION 's3://amzn-s3-demo-bucket/123456789012/CloudTrail/us-east-1/2016/03/14/'.` 
   + Para analisar dados de atividade de rede em vez de eventos de gerenciamento, substitua `/CloudTrail/` na cláusula `LOCATION` por `/CloudTrail-NetworkActivity/`. 

   O uso do nível mais alto na hierarquia de objetos proporciona maior flexibilidade ao consultar usando o Athena.

1. Verifique se os campos estão listados corretamente. Para obter mais informações sobre a lista completa de campos em um registro do CloudTrail, consulte [Conteúdo do registro do CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html).

   A declaração de exemplo `CREATE TABLE` na Etapa 1 usa [Hive JSON SerDe](hive-json-serde.md). No exemplo, os campos `requestparameters`, `responseelements` e `additionaleventdata` são listados como tipo `STRING` na consulta, mas são tipos de dados `STRUCT` usados em JSON. Portanto, para obter dados desses campos, use funções `JSON_EXTRACT`. Para obter mais informações, consulte [Extrair dados JSON de strings](extracting-data-from-JSON.md). Para melhorias de performance, o exemplo particiona os dados por Região da AWS, ano, mês e dia.

1. Execute a instrução `CREATE TABLE` no console do Athena.

1. Use o comando [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) a fim de carregar as partições para que você consiga consultá-las, conforme o exemplo a seguir.

   ```
   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/'
   ```

# Criar uma tabela para uma trilha em toda a organização usando particionamento manual
<a name="create-cloudtrail-table-org-wide-trail"></a>

Para criar uma tabela para arquivos de log do CloudTrail em toda a organização no Athena, siga as etapas listadas em [Criar uma tabela de logs do CloudTrail no Athena usando particionamento manual](create-cloudtrail-table.md), mas faça as modificações observadas no procedimento a seguir.

**Criar uma tabela do Athena para logs do CloudTrail em toda a organização**

1. Na instrução `CREATE TABLE`, modifique a cláusula `LOCATION` para incluir o ID da organização, como no exemplo a seguir:

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

1. Na cláusula `PARTITIONED BY`, adicione uma entrada para o ID da conta como cadeia de caracteres, como no exemplo a seguir:

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

   O exemplo a seguir mostra o resultado combinado:

   ```
   ...
   
   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. Na instrução `ALTER TABLE`, na cláusula `ADD PARTITION`, inclua o ID da organização, como no exemplo a seguir:

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

1. Na instrução `ALTER TABLE`, na cláusula `LOCATION`, inclua o ID da organização, o ID da conta e a partição que você deseja adicionar, como no exemplo a seguir:

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

   No exemplo a seguir, a instrução `ALTER TABLE` mostra o resultado combinado:

   ```
   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/'
   ```

Observe que, em uma grande organização, usar esse método para adicionar e manter manualmente uma partição para cada ID de conta da organização pode ser complicado. Nesse cenário, considere usar o CloudTrail Lake em vez do Athena. O CloudTrail Lake oferece as seguintes vantagens:
+ Agrega automaticamente os logs em toda a organização
+ Não requer configuração ou manutenção de partições ou de uma tabela do Athena
+ As consultas são executadas diretamente no console do CloudTrail
+ Usa uma linguagem de consultas compatível com SQL

Para obter mais informações, consulte [Trabalhar com o AWS Lake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html), no *Guia do usuário do AWS CloudTrail*. 

# Criar a tabela para logs do CloudTrail no Athena usando a projeção de partições
<a name="create-cloudtrail-table-partition-projection"></a>

Como os logs do CloudTrail têm uma estrutura conhecida com um esquema de partição que você pode especificar antecipadamente, é possível reduzir o runtime das consultas e automatizar o gerenciamento de partições usando o atributo de projeção de partições do Athena. A projeção de partições adiciona automaticamente novas partições à medida que os dados são adicionados. Isso elimina a necessidade de adicionar manualmente as partições usando `ALTER TABLE ADD PARTITION`. 

A instrução de exemplo `CREATE TABLE` a seguir usa automaticamente a projeção de partições com base nos logs do CloudTrail a partir de uma data especificada até o dia de hoje para uma única Região da AWS. Nas cláusulas `LOCATION` e `storage.location.template`, substitua os espaços reservados *bucket*, *account-id* e *aws-region* pelos valores idênticos correspondentes. Em ‭`projection.timestamp.range`‬, substitua ‭*2020*/*01*/*01* pela data de início que você deseja usar. Depois que você executar a consulta com êxito, poderá consultar a tabela. Você não precisa executar `ALTER TABLE ADD PARTITION` para carregar as partições.

```
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}')
```

Para obter mais informações sobre projeção de partições, consulte [Usar projeção de partições com o Amazon Athena](partition-projection.md).

# Exemplo de consultas de log do CloudTrail
<a name="query-examples-cloudtrail-logs"></a>

O exemplo a seguir mostra a parte de uma consulta que retorna todas as solicitações anônimas (não assinadas) da tabela criada para os logs de eventos do CloudTrail. Essa consulta seleciona as solicitações em que `useridentity.accountid` são anônimos e `useridentity.arn` não é especificado:

```
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 ]%';
```

Para obter mais informações, consulte a publicação no Blog de Big Data da AWS, [Análise de segurança, conformidade e atividades operacionais usando o AWS CloudTrail e o Amazon Athena](https://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/).

## Consulta de campos aninhados nos logs do CloudTrail
<a name="cloudtrail-logs-nested-fields"></a>

Como os campos `userIdentity` e `resources` são tipos de dados aninhados, é necessário um tratamento especial para consultá-los.

O objeto `userIdentity` consiste em tipos `STRUCT` aninhados. É possível consultá-los usando um ponto para separar os campos, como no seguinte exemplo:

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

O campo `resources` é um array de objetos `STRUCT`. Para esses arrays, use `CROSS JOIN UNNEST` para remover o aninhamento do array de modo que você possa consultar seus objetos.

O exemplo a seguir retorna todas as linhas em que o ARN do recurso termina com `example/datafile.txt`. Para legibilidade, a função [replace](https://prestodb.io/docs/current/functions/string.html#replace) remove a substring inicial `arn:aws:s3:::` do 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
```

Veja a seguir exemplos de consultas de eventos `DeleteBucket`. A consulta extrai do objeto `resources` o nome do bucket e o ID da conta à qual o bucket pertence.

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

Para obter mais informações sobre como remover o aninhamento, consulte [Filtrar matrizes](filtering-arrays.md).

## Dicas para consultar logs do CloudTrail
<a name="tips-for-querying-cloudtrail-logs"></a>

Considere o seguinte ao explorar dados do log do CloudTrail:
+ Antes de consultar os logs, verifique se a tabela de logs tem a mesma aparência da tabela em [Criar uma tabela de logs do CloudTrail no Athena usando particionamento manual](create-cloudtrail-table.md). Se não for a primeira tabela, exclua a tabela existente usando o seguinte comando: `DROP TABLE cloudtrail_logs`.
+ Depois de ignorar a tabela existente, recrie-a. Para obter mais informações, consulte [Criar uma tabela de logs do CloudTrail no Athena usando particionamento manual](create-cloudtrail-table.md).

  Verifique se os campos na consulta do Athena estão listados corretamente. Para obter informações sobre a lista completa de campos em um registro do CloudTrail, consulte [Conteúdo do registro do CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html). 

  Se a consulta incluir campos em formatos JSON, como `STRUCT`, extraia dados de JSON. Para obter mais informações, consulte [Extrair dados JSON de strings](extracting-data-from-JSON.md). 

  Algumas sugestões para realizar consultas em sua tabela do CloudTrail:
+ Comece observando quais usuários do chamaram quais operações da API e de quais endereços IP de origem.
+ Use a consulta SQL básica a seguir como o modelo. Cole a consulta no console do Athena e execute-a.

  ```
  SELECT
   useridentity.arn,
   eventname,
   sourceipaddress,
   eventtime
  FROM cloudtrail_logs
  LIMIT 100;
  ```
+ Modifique a consulta para explorar ainda mais seus dados.
+ Para melhorar a performance, inclua a cláusula `LIMIT` para retornar um subconjunto especificado de linhas.

# Consulta a logs do Amazon EMR
<a name="emr-logs"></a>

As aplicações do Amazon EMR e de big data executadas no Amazon EMR geram arquivos de log. Os arquivos de log são gravados no [nó primário](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html), e você também pode configurar o Amazon EMR para armazená-los automaticamente no Amazon S3. Você pode usar o Amazon Athena para consultar esses logs e identificar eventos e tendências de aplicações e clusters. Para obter mais informações sobre os tipos de arquivos de log no Amazon EMR e como salvá-los no Amazon S3, consulte [View log files](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-manage-view-web-log-files.html) (Exibir arquivos de log) no *Guia de gerenciamento do Amazon EMR*.

**Topics**
+ [Criação e consulta a uma tabela básica baseada em arquivos de log do Amazon EMR](emr-create-table.md)
+ [Criar e consultar uma tabela particionada baseada nos logs do Amazon EMR](emr-create-table-partitioned.md)

# Criação e consulta a uma tabela básica baseada em arquivos de log do Amazon EMR
<a name="emr-create-table"></a>

O exemplo a seguir cria uma tabela básica, `myemrlogs`, com base em arquivos de log salvos em `s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/elasticmapreduce/`. O local do Amazon S3 usado nos exemplos abaixo reflete o padrão do local predefinido dos logs de um cluster do EMR criado pela conta da Amazon Web Services *123456789012* na região *us-west-2*. Se você usar um local personalizado, o padrão será s3://amzn-s3-demo-bucket/*ClusterID*.

Para obter informações sobre a criação de uma tabela particionada para potencialmente aprimorar a performance da consulta e reduzir a transferência de dados, consulte [Criar e consultar uma tabela particionada baseada nos logs do 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'
```

## Consultas de exemplo
<a name="emr-example-queries-basic"></a>

Os exemplos de consultas a seguir podem ser executados na tabela `myemrlogs` criada pelo exemplo anterior.

**Example – Consultar os logs de etapas para ocorrências de ERROR, WARN, INFO, EXCEPTION, FATAL ou 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 – Consultar um log de instância específico, i-00b3c0a839ece0a9c, para ERROR, WARN, INFO, EXCEPTION, FATAL ou 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 – Consultar os logs da aplicação Presto para ERROR, WARN, INFO, EXCEPTION, FATAL ou 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 – Consultar os logs da aplicação Namenode para ERROR, WARN, INFO, EXCEPTION, FATAL ou 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 – Consultar todos os logs por data e hora para ERROR, WARN, INFO, EXCEPTION, FATAL ou 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;
```

# Criar e consultar uma tabela particionada baseada nos logs do Amazon EMR
<a name="emr-create-table-partitioned"></a>

Esses exemplos usam o mesmo local de log para criar uma tabela do Athena, mas a tabela é particionada e uma partição é criada para cada local de log. Para obter mais informações, consulte [Particionar dados](partitions.md).

A consulta a seguir cria a tabela particionada denominada `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'
```

Na sequência, as instruções de consulta a seguir criam as partições de tabela com base nos subdiretórios dos tipos diferentes de log que o Amazon EMR cria no 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/'
```

Depois de criar as partições, você pode executar uma consulta `SHOW PARTITIONS` na tabela para confirmar:

```
SHOW PARTITIONS mypartitionedemrlogs;
```

## Consultas de exemplo
<a name="emr-example-queries-partitioned"></a>

Os exemplos a seguir demonstram que consultas para entradas de log específicas usam a tabela e as partições criadas pelos exemplos acima.

**Example – Consultar os logs da aplicação application\$11561661818238\$10002 na partição de contêineres para ERROR ou 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 – Consultar a partição Hadoop-Mapreduce do trabalho job\$11561661818238\$10004 e as falhas de redução**  

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

**Example – Consultar os logs do Hive na partição do nó em relação ao ID de consulta 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 – Consultar os logs do Resourcemanager na partição do nó em relação à aplicação 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
```

# Consultar logs de fluxo do AWS Global Accelerator
<a name="querying-global-accelerator-flow-logs"></a>

É possível usar o AWS Global Accelerator para criar aceleradoras que direcionam o tráfego de rede para endpoints ideais na rede global da AWS. Para obter mais informações sobre o Global Accelerator, consulte [What is AWS Global Accelerator?](https://docs.aws.amazon.com/global-accelerator/latest/dg/what-is-global-accelerator.html) (O que é o ?).

Os logs de fluxo do Global Accelerator permitem que você capture as informações sobre o tráfego de endereço IP que entra e sai das interfaces de rede em suas aceleradoras. Os dados do log de fluxo são publicados no Amazon S3, de onde é possível recuperá-los e visualizá-los. Para obter mais informações, consulte [Flow logs in AWS Global Accelerator](https://docs.aws.amazon.com/global-accelerator/latest/dg/monitoring-global-accelerator.flow-logs.html) (Logs de fluxo do ).

É possível usar o Athena para consultar os logs de fluxo do Global Accelerator criando uma tabela que especifica o local deles no Amazon S3.

**Para criar a tabela de logs de fluxo do Global Accelerator**

1. Copie e cole a instrução DDL a seguir no console do Athena. Esta consulta especifica *ROW FORMAT DELIMITED* e omite a especificação de um [SerDe](serde-reference.md), o que significa que a consulta usa [`LazySimpleSerDe`](lazy-simple-serde.md). Nesta consulta, os campos terminam com um espaço.

   ```
   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. Modifique o valor `LOCATION` para apontar para o bucket do Amazon S3 que contém os dados de log.

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

1. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `aga_flow_logs`, disponibilizando os dados dela para consultas.

1. Crie partições para ler os dados, conforme a consulta de exemplo a seguir. Esta consulta cria uma única partição para uma data especificada. Substitua os espaços reservados por data e local.

   ```
   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';
   ```

## Consultas de exemplo para logs de fluxo do AWS Global Accelerator
<a name="querying-global-accelerator-flow-logs-examples"></a>

**Example – Listar as solicitações que passam por um local da borda específico**  
A consulta de exemplo a seguir lista as solicitações que passaram pelo ponto de presença do LHR. Use o operador `LIMIT` para limitar o número de logs a serem consultados por vez.  

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

**Example – Listar os endereços IP dos endpoints que recebem a maioria das solicitações HTTPS**  
Para ver quais endereços IP do endpoint estão recebendo o maior número de solicitações HTTPS, use a seguinte consulta. Esta consulta conta o número de pacotes recebidos na porta HTTPS 443, agrupa-os por endereço IP de destino e retorna os 10 principais endereços IP.  

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

# Consultar descobertas do Amazon GuardDuty
<a name="querying-guardduty"></a>

O [Amazon GuardDuty](https://aws.amazon.com/guardduty/) é um serviço de monitoramento de segurança que ajuda a identificar atividades inesperadas e potencialmente mal-intencionadas ou não autorizadas em seu ambiente AWS. Quando detecta atividades inesperadas e potencialmente mal-intencionadas, o GuardDuty gera [descobertas](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_findings.html) de segurança que você pode exportar para o Amazon S3 para armazenamento e análise. Depois de exportar as descobertas para o Amazon S3, você pode usar o Athena para consultá-las. Este artigo mostra como criar uma tabela no Athena para as descobertas do GuardDuty e consultá-las.

Para obter mais informações sobre o Amazon GuardDuty, consulte o [Manual do usuário do Amazon GuardDuty](https://docs.aws.amazon.com/guardduty/latest/ug/).

## Pré-requisitos
<a name="querying-guardduty-prerequisites"></a>
+ Habilite o recurso GuardDuty para exportar as descobertas para o Amazon S3. Para conhecer as etapas, consulte [Exporting findings](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_exportfindings.html) (Exportar descobertas) no Guia do usuário do Amazon GuardDuty.

## Criar uma tabela no Athena para as descobertas do GuardDuty
<a name="querying-guardduty-creating-a-table-in-athena-for-guardduty-findings"></a>

Para consultar as descobertas do GuardDuty no Athena, crie uma tabela para elas.

**Para criar uma tabela no Athena para as descobertas do GuardDuty**

1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Copie a instrução DDL a seguir no console do Athena. Modifique os valores em `LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/account-id/GuardDuty/'` para apontar para as descobertas do GuardDuty no 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**  
O SerDe espera que cada documento JSON esteja em uma única linha de texto, sem caracteres de terminação de linha separando os campos no registro. Se o texto JSON estiver formatado para impressão, você poderá receber uma mensagem de erro como HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object (HIVE\$1CURSOR\$1ERROR: a linha não é um objeto JSON válido) ou HIVE\$1CURSOR\$1ERROR: JsonParseException: Unexpected end-of-input: expected close marker for OBJECT (HIVE\$1CURSOR\$1ERROR: JSONParseException: Fim de entrada inesperado: marcador de fechamento esperado para OBJECT) quando tentar consultar a tabela após criá-la. Para obter mais informações, consulte [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) na documentação do OpenX SerDe no GitHub. 

1. Execute a consulta no console do Athena para registrar a tabela `gd_logs`. Quando a consulta for concluída, as descobertas estarão prontas para serem consultadas no Athena.

## Consultas de exemplo
<a name="querying-guardduty-examples"></a>

Os exemplos a seguir mostram como consultar as descobertas do GuardDuty no Athena.

**Example – Exfiltração de dados de DNS**  
A consulta a seguir retorna informações sobre as instâncias do Amazon EC2 que podem estar exfiltrando dados por meio das consultas de 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 – Acesso de usuário do IAM não autorizado**  
A consulta a seguir retorna todos os tipos de descoberta `UnauthorizedAccess:IAMUser` referentes a um principal do IAM de todas as regiões.   

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

## Dicas para consultar descobertas do GuardDuty
<a name="querying-guardduty-tips"></a>

Ao criar a consulta, mantenha os seguintes pontos em mente.
+ Para extrair dados de campos JSON aninhados, use as funções `json_extract` ou `json_extract_scalar` do Presto. Para ter mais informações, consulte [Extrair dados JSON de strings](extracting-data-from-JSON.md).
+ Certifique-se de que todos os caracteres nos campos JSON estejam em minúsculas.
+  Para obter informações sobre como baixar resultados de consulta, verifique [Baixar arquivos de resultados de consultas via console do Athena](saving-query-results.md).

# Consultar logs do AWS Network Firewall
<a name="querying-network-firewall-logs"></a>

AWS Network Firewall é um serviço gerenciado que você pode usar para implantar proteções de rede essenciais em suas instâncias do Amazon Virtual Private Cloud. O AWS Network Firewall funciona em conjunto com o AWS Firewall Manager para que você possa criar políticas com base nas regras do AWS Network Firewall e aplicá-las a suas VPCs e contas de maneira centralizada. Para obter mais informações sobre AWS Network Firewall, consulte [AWS Network Firewall](https://aws.amazon.com/network-firewall/).

É possível configurar os logs do AWS Network Firewall para o tráfego que você encaminha para o mecanismo de regras com estado do firewall. Os logs apresentam informações detalhadas sobre o tráfego de rede, incluindo a hora em que o mecanismo com estado recebeu um pacote, os detalhes do pacote e qualquer ação de regra com estado realizada no pacote. Os logs são publicados no destino de logs que você configurou, de onde é possível recuperá-los e visualizá-los. Para obter mais informações, consulte [Registrar o tráfego de rede do AWS Network Firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html) no *Guia do desenvolvedor do AWS Network Firewall* (em inglês).

**Topics**
+ [Criar e consultar uma tabela para logs de alertas](querying-network-firewall-logs-sample-alert-logs-table.md)
+ [Criar e consultar uma tabela para logs de fluxo de rede](querying-network-firewall-logs-sample-netflow-logs-table.md)

# Criar e consultar uma tabela para logs de alertas
<a name="querying-network-firewall-logs-sample-alert-logs-table"></a>

1. Modifique o exemplo de instrução DDL a seguir para se adequar à estrutura do seu log de alertas. Pode ser necessário atualizar a instrução para incluir as colunas da versão mais recente dos logs. Para obter mais informações, consulte [Conteúdo de um log de firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html#firewall-logging-contents) no *Guia do desenvolvedor do 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. Modifique a cláusula `LOCATION` para especificar a pasta para seus logs no Amazon S3.

1. Execute sua consulta `CREATE TABLE` no editor de consultas do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `network_firewall_alert_logs`, preparando os dados para os quais ela direciona para as consultas.

## Consulta de exemplo
<a name="querying-network-firewall-logs-alert-log-sample-query"></a>

O exemplo de consulta de log de alertas nesta seção filtra os eventos nos quais a inspeção TLS foi realizada e que têm alertas com um nível de severidade de 2 ou superior.

A consulta usa aliases para criar cabeçalhos de coluna de saída que mostram o `struct` ao qual a coluna pertence. Por exemplo, o título da coluna do campo `event.alert.category` é `event_alert_category` em vez de apenas`category`. Para personalizar ainda mais os nomes das colunas, você pode modificar os aliases de acordo com suas preferências. Por exemplo, você pode usar sublinhados ou outros separadores para delimitar os nomes de `struct` e os nomes dos campos. 

Lembre-se de modificar os nomes de colunas e as referências de `struct` com base na definição da tabela e nos campos que você deseja no resultado da consulta.

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

# Criar e consultar uma tabela para logs de fluxo de rede
<a name="querying-network-firewall-logs-sample-netflow-logs-table"></a>

1. Modifique o exemplo de instrução DDL a seguir para se adequar à estrutura do seu log de fluxo de redes. Pode ser necessário atualizar a instrução para incluir as colunas da versão mais recente dos logs. Para obter mais informações, consulte [Conteúdo de um log de firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html#firewall-logging-contents) no *Guia do desenvolvedor do 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. Modifique a cláusula `LOCATION` para especificar a pasta para seus logs no Amazon S3.

1. Execute a consulta `CREATE TABLE` no editor de consultas do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `network_firewall_netflow_logs`, preparando os dados para os quais ela direciona para as consultas.

## Consulta de exemplo
<a name="querying-network-firewall-logs-netflow-log-sample-query"></a>

O exemplo de consulta de log do Netflow nesta seção filtra os eventos nos quais a inspeção TLS foi realizada.

A consulta usa aliases para criar cabeçalhos de coluna de saída que mostram o `struct` ao qual a coluna pertence. Por exemplo, o título da coluna do campo `event.netflow.bytes` é `event_netflow_bytes` em vez de apenas`bytes`. Para personalizar ainda mais os nomes das colunas, você pode modificar os aliases de acordo com suas preferências. Por exemplo, você pode usar sublinhados ou outros separadores para delimitar os nomes de `struct` e os nomes dos campos. 

Lembre-se de modificar os nomes de colunas e as referências de `struct` com base na definição da tabela e nos campos que você deseja no resultado da consulta.

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

# Consultar logs do Network Load Balancer
<a name="networkloadbalancer-classic-logs"></a>

Use o Athena para analisar e processar os logs do Network Load Balancer. Esses logs recebem informações detalhadas sobre as solicitações Transport Layer Security (TLS) enviadas ao Network Load Balancer. Você pode usar esses logs de acesso para analisar padrões de tráfego e solucionar problemas. 

Antes de analisar os logs de acesso do Network Load Balancer, habilite-os e configure-os para serem salvos no bucket de destino do Amazon S3. Para obter mais informações, além de informações sobre cada entrada de log de acesso do Network Load Balancer, consulte [Access logs for your Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-access-logs.html).

**Para criar a tabela de logs do Network Load Balancer**

1. Copie e cole a instrução DDL a seguir no console do Athena. Verifique a [sintaxe ](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-access-logs.html#access-log-file-format) dos registros de log do Network Load Balancer. Atualize a instrução conforme necessário para incluir as colunas e o regex correspondentes aos seus registros de 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. Modifique o bucket `LOCATION` do Amazon S3 para especificar o destino dos logs do Network Load Balancer.

1. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `nlb_tls_logs`, preparando os dados dela para as consultas.

## Consultas de exemplo
<a name="query-nlb-example"></a>

Para ver quantas vezes um certificado é usado, use uma consulta semelhante a este exemplo:

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

A consulta a seguir mostra quantos usuários estão usando uma versão do TLS anterior à versão 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;
```

Use a consulta a seguir para identificar conexões que levam muito tempo de handshake do TLS.

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

Use a consulta a seguir para identificar e contar as versões de protocolo TLS e os conjuntos de cifras que foram negociados nos últimos 30 dias.

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

# Consultar logs de consultas do Amazon Route 53 Resolver
<a name="querying-r53-resolver-logs"></a>

Você pode criar tabelas do Athena para seus logs de consulta do Amazon Route 53 Resolver e consultá-las no Athena.

O log de consulta do Route 53 Resolver é destinado ao registro de consultas de DNS feitas por recursos em uma VPC, recursos on-premises que usam endpoints do Resolver de entrada, consultas que usam um endpoint do Resolver de saída para resolução de DNS recursiva e consultas que usam regras de firewall de DNS do Route 53 Resolver para bloquear, permitir ou monitorar uma lista de domínios. Para obter mais informações sobre o log de consulta do Resolver, veja [Log de consulta do Resolver](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-query-logs.html) no *Guia do desenvolvedor do Amazon Route 53*. Para obter informações sobre cada um dos campos nos logs, consulte [Valores que aparecem em logs de consultas do Resolver](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-query-logs-format.html) no *Guia do desenvolvedor do Amazon Route 53*.

**Topics**
+ [Criar a tabela de logs de consulta do resolvedor](querying-r53-resolver-logs-creating-the-table.md)
+ [Usar projeção de partições](querying-r53-resolver-logs-partitioning-example.md)
+ [Consultas de exemplo](querying-r53-resolver-logs-example-queries.md)

# Criar a tabela de logs de consulta do resolvedor
<a name="querying-r53-resolver-logs-creating-the-table"></a>

Você pode usar o editor de consultas no console do Athena para criar e consultar uma tabela com os logs de consulta do Route 53 Resolver.

**Para criar e consultar uma tabela do Athena com os logs de consulta do Route 53 Resolver**

1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. No editor de consultas do Athena, insira a instrução `CREATE TABLE` a seguir. Substitua os valores da cláusula `LOCATION` pelos correspondentes ao local dos logs do Resolver no 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}/'
   ```

   Como os dados de log de consulta do Resolver estão no formato JSON, a instrução CREATE TABLE usa a [Biblioteca SerDe do JSON](json-serde.md) para analisar os dados.
**nota**  
O SerDe espera que cada documento JSON esteja em uma única linha de texto, sem caracteres de terminação de linha separando os campos no registro. Se o texto JSON estiver formatado para impressão, você poderá receber uma mensagem de erro como HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object (HIVE\$1CURSOR\$1ERROR: a linha não é um objeto JSON válido) ou HIVE\$1CURSOR\$1ERROR: JsonParseException: Unexpected end-of-input: expected close marker for OBJECT (HIVE\$1CURSOR\$1ERROR: JSONParseException: Fim de entrada inesperado: marcador de fechamento esperado para OBJECT) quando tentar consultar a tabela após criá-la. Para obter mais informações, consulte [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) na documentação do OpenX SerDe no GitHub. 

1. Selecione **Executar consulta**. A instrução cria uma tabela do Athena chamada `r53_rlogs` com colunas que representam cada um dos campos em seus dados de log do Resolver.

1. No editor de consultas do console do Athena, execute a consulta a seguir para verificar se a tabela foi criada.

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

# Usar projeção de partições
<a name="querying-r53-resolver-logs-partitioning-example"></a>

O exemplo a seguir mostra uma declaração `CREATE TABLE` para logs de consulta do Resolver que usa projeção de partição e é particionada por VPC e por data. Para obter mais informações sobre projeção de partições, consulte [Usar projeção de partições com o 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}/'
)
```

# Consultas de exemplo
<a name="querying-r53-resolver-logs-example-queries"></a>

Os exemplos a seguir mostram algumas consultas do Athena que você pode executar em seus logs de consulta do Resolver.

## Exemplo 1: logs de consulta em ordem decrescente de query\$1timestamp
<a name="querying-r53-resolver-logs-example-1-query-logs-in-descending-query_timestamp-order"></a>

A consulta a seguir exibe os resultados do log em ordem decrescente de `query_timestamp`.

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

## Exemplo 2: logs de consulta com horários de início e de término específicos
<a name="querying-r53-resolver-logs-example-2-query-logs-within-specified-start-and-end-times"></a>

As consultas a seguir analisam os logs entre meia-noite e 8h no dia 24 de setembro de 2020. Substitua os horários de início e de término de acordo com os seus requisitos.

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

## Exemplo 3: logs de consulta baseados em um padrão de nome especificado de consulta de DNS
<a name="querying-r53-resolver-logs-example-3-query-logs-based-on-a-specified-dns-query-name-pattern"></a>

A consulta a seguir seleciona os registros com nome de consulta que inclui a string “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
```

## Exemplo 4: solicitações de log de consulta sem resposta
<a name="querying-r53-resolver-logs-example-4-query-log-requests-with-no-answer"></a>

A consulta a seguir seleciona as entradas de log em que a solicitação não recebeu resposta.

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

## Exemplo 5: logs de consulta com uma resposta específica
<a name="querying-r53-resolver-logs-example-5-query-logs-with-a-specific-answer"></a>

A consulta a seguir mostra os logs nos quais o valor `answer.Rdata` tem o endereço IP especificado.

```
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';
```

# Consultar logs de eventos do Amazon SES
<a name="querying-ses-logs"></a>

É possível utilizar o Amazon Athena para consultar logs de eventos do [Amazon Simple Email Service](https://aws.amazon.com/ses/) (Amazon SES).

O Amazon SES é uma plataforma de e-mail que oferece uma forma conveniente e com bom custo-benefício de enviar e receber e-mails usando seus próprios endereços de e-mail e domínios. Você pode monitorar suas atividades de envio do Amazon SES em nível granular usando eventos, métricas e estatísticas.

Com base nas características que você define, é possível publicar eventos do Amazon SES no [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/), no [Amazon Data Firehose](https://aws.amazon.com/kinesis/data-firehose/) ou no [Amazon Simple Notification Service](https://aws.amazon.com/sns/). Depois que as informações forem armazenadas no Amazon S3, você poderá consultá-las no Amazon Athena. 

Para ver um exemplo de declaração `CREATE TABLE` do Athena para os logs do Amazon SES, incluindo etapas sobre como criar visualizações e nivelar arrays aninhadas nos dados do log de eventos do Amazon SES, consulte "Step 3: Using Amazon Athena to query the SES event logs" na postagem do blog da AWS, [Analyzing Amazon SES event data with AWS Analytics Services](https://aws.amazon.com/blogs/messaging-and-targeting/analyzing-amazon-ses-event-data-with-aws-analytics-services/).

# Consultar os logs de fluxo do Amazon VPC
<a name="vpc-flow-logs"></a>

Os logs de fluxo do Amazon Virtual Private Cloud capturam informações do tráfego de IP de entrada e saída das interfaces de rede em uma VPC. Use os logs para investigar padrões de tráfego de rede e identificar ameaças e riscos em toda a rede da VPC.

Para consultar seus logs de fluxo da Amazon VPC, você tem duas opções:

****
+ **Console do Amazon VPC**: use o recurso de integração do Athena no console do Amazon VPC para gerar um modelo do CloudFormation que cria um banco de dados, um grupo de trabalho e uma tabela de logs de fluxo do Athena com particionamento para você. O modelo também cria um conjunto de [consultas de log de fluxo predefinidas](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html#predefined-queries) que você pode usar para obter insights sobre o tráfego que passa pela VPC.

  Para obter mais informações sobre essa abordagem, consulte [Consultar logs de fluxo usando o Amazon Athena](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html) no *Guia do usuário da Amazon VPC*.
+ **Console do Amazon Athena**: crie suas tabelas e consultas diretamente no console do Athena. Para obter mais informações, continue lendo esta página.

Antes de começar a consultar os logs no Athena, [habilite os logs de fluxo da VPC](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/flow-logs.html) e configure-os para serem salvos em seu bucket do Amazon S3. Depois de criar os logs, deixe-os em execução por alguns minutos para coletar alguns dados. Os logs são criados no formato de compactação GZIP que o Athena permite que você consulte diretamente. 

Ao criar um log de fluxo da VPC, você pode usar um formato personalizado quando desejar especificar os campos que devem ser retornados no log de fluxo e a ordem em que devem aparecer. Para obter mais informações sobre registros de logs de fluxo, consulte [Registros de log de fluxo](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records) no *Guia do usuário da Amazon VPC*.

## Considerações e limitações
<a name="vpc-flow-logs-common-considerations"></a>

Ao criar tabelas no Athena para logs de fluxo da Amazon VPC, lembre-se dos seguintes pontos:
+ Por padrão, no Athena, o Parquet acessará as colunas por nome. Para obter mais informações, consulte [Lidar com atualizações de esquemas](handling-schema-updates-chapter.md).
+ Use os nomes nos registros de log de fluxo para os nomes das colunas no Athena. Os nomes das colunas no esquema do Athena devem corresponder exatamente aos nomes dos campos nos logs de fluxo da Amazon VPC, com as seguintes diferenças: 
  + Substitua os hifens nos nomes dos campos do log da Amazon VPC por sublinhados nos nomes das colunas do Athena. Para obter informações sobre caracteres aceitáveis em nomes de bancos de dados, nomes de tabelas e nomes de colunas no Athena, consulte [Nomear bancos de dados, tabelas e colunas](tables-databases-columns-names.md).
  + Escape os nomes de registro do log de fluxo que são [palavras-chave reservadas](reserved-words.md) no Athena, colocando-os entre caracteres de crase. 
+ Os logs de fluxos da VPC são específicos da Conta da AWS. Quando você publica seus arquivos de log no Amazon S3, o caminho criado pela Amazon VPC no Amazon S3 inclui o ID da Conta da AWS que foi usada para criar o log de fluxo. Para obter mais informações, consulte [Publicar logs de fluxo no Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-s3.html), no *Guia do usuário da Amazon VPC*.

**Topics**
+ [Considerações e limitações](#vpc-flow-logs-common-considerations)
+ [Criar e consultar uma tabela para logs de fluxo da Amazon VPC](vpc-flow-logs-create-table-statement.md)
+ [Criar tabelas para logs de fluxo no formato Apache Parquet](vpc-flow-logs-parquet.md)
+ [Criar e consultar uma tabela para logs de fluxo da Amazon VPC com o uso de projeção de partições](vpc-flow-logs-partition-projection.md)
+ [Criar tabelas para logs de fluxo no formato do Apache Parquet com o uso de projeção de partições](vpc-flow-logs-partition-projection-parquet-example.md)
+ [Recursos adicionais](query-examples-vpc-logs-additional-resources.md)

# Criar e consultar uma tabela para logs de fluxo da Amazon VPC
<a name="vpc-flow-logs-create-table-statement"></a>

O procedimento a seguir cria uma tabela da Amazon VPC para os logs de fluxo da Amazon VPC. Ao criar um log de fluxo em um formato personalizado, você cria uma tabela com campos que correspondem aos campos especificados quando criou o log de fluxo, na mesma ordem em que os especificou.

**Para criar uma tabela do Athena para logs de fluxo da Amazon VPC**

1. Insira uma instrução DDL como a que se segue no editor de consultas do console do Athena, seguindo as diretrizes na seção [Considerações e limitações](vpc-flow-logs.md#vpc-flow-logs-common-considerations). A instrução do exemplo cria uma tabela com as colunas de logs de fluxo da Amazon VPC nas versões 2 a 5, conforme documentado em [Registros de log de fluxo](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records). Se você usar outro conjunto ou outra ordem de colunas, modifique a instrução conforme apropriado.

   ```
   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");
   ```

   Observe os seguintes pontos:
   + A consulta especifica `ROW FORMAT DELIMITED` e omite a especificação de um SerDe. Isso significa que a consulta usa [Lazy Simple SerDe para arquivos CSV, TSV e com delimitação personalizada](lazy-simple-serde.md). Nesta consulta, os campos terminam com um espaço.
   + A cláusula `PARTITIONED BY` usa o tipo `date`. Isso torna possível usar operadores matemáticos em consultas para selecionar qual é mais antiga ou mais recente em relação a uma determinada data.
**nota**  
Como `date` é uma palavra-chave reservada em instruções DDL, é necessário fazer o escape dela com acentos graves. Para obter mais informações, consulte [Escapar palavras-chave reservadas em consultas](reserved-words.md).
   + Para um log de fluxo da VPC com um formato personalizado diferente, modifique os campos para que correspondam aos campos especificados ao criar o log de fluxo.

1. Modifique `LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/{region_code}/'` para apontar para o bucket do Amazon S3 que contém os dados de log.

1. Execute a consulta no console do Athena. Depois que a consulta for concluída, o Athena registrará a tabela `vpc_flow_logs`, preparando os dados dela para você fazer as consultas.

1. Crie partições para poder ler os dados, conforme o exemplo de consulta a seguir. Esta consulta cria uma única partição para uma data especificada. Substitua os espaços reservados por data e local, conforme necessário. 
**nota**  
Esta consulta cria apenas uma única partição, para uma data especificada por você. Para automatizar o processo, use um script que execute essa consulta e crie partições dessa maneira para `year/month/day` ou use uma instrução `CREATE TABLE` que especifique a [projeção das partições](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';
   ```

## Exemplos de consulta para a tabela vpc\$1flow\$1logs
<a name="query-examples-vpc-logs"></a>

Use o editor de consultas no console do Athena para executar instruções SQL na tabela criada. É possível salvar as consultas, visualizar consultas anteriores ou baixar os resultados da consulta no formato CSV. Nos exemplos a seguir, substitua `vpc_flow_logs` pelo nome da tabela. Modifique os valores das colunas e outras variáveis de acordo com os seus requisitos.

A consulta de exemplo a seguir lista um máximo de 100 logs de fluxo para a data especificada.

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

A consulta a seguir lista todas as conexões TCP rejeitadas e usa a coluna de partição de data recém-criada, `date`, para extrair dela o dia da semana em que ocorreram esses eventos.

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

Para ver qual dos servidores está recebendo o maior número de solicitações HTTPS, use a consulta a seguir. Ela conta o número de pacotes recebidos na porta HTTPS 443, agrupa-os por endereço IP de destino e retorna os 10 principais da última semana.

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

# Criar tabelas para logs de fluxo no formato Apache Parquet
<a name="vpc-flow-logs-parquet"></a>

O procedimento a seguir cria uma tabela da Amazon VPC para os logs de fluxo da Amazon VPC no formato Apache Parquet.

**Para criar uma tabela do Athena para logs de fluxo da Amazon VPC no formato Parquet**

1. Insira uma instrução DDL como a que se segue no editor de consultas do console do Athena, seguindo as diretrizes na seção [Considerações e limitações](vpc-flow-logs.md#vpc-flow-logs-common-considerations). A instrução do exemplo cria uma tabela com as colunas de logs de fluxo da Amazon VPC nas versões 2 a 5, conforme documentado em [Registros de log de fluxo](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records) no formato Parquet, com partição do Hive por hora. Se você não tiver partições por hora, remova `hour` da cláusula `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. Modifique a amostra `LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/'` para apontar para o caminho do Amazon S3 que contém os dados de log.

1. Execute a consulta no console do Athena.

1. Se os dados estiverem em um formato compatível com o Hive, execute o comando a seguir no console do Athena para atualizar e carregar as partições do Hive no metastore. Após a conclusão da consulta, você pode consultar os dados na tabela `vpc_flow_logs_parquet`.

   ```
   MSCK REPAIR TABLE vpc_flow_logs_parquet
   ```

   Se não estiver usando dados compatíveis com o Hive, execute [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) para carregar as partições.

Para obter mais informações sobre como usar o Athena para consultar logs de fluxo da Amazon VPC no formato Parquet, consulte a publicação [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/) (Otimize a performance e reduza os custos de análise de rede com logs de fluxo da VPC no formato Apache Parquet) no *blog sobre big data da AWS*.

# Criar e consultar uma tabela para logs de fluxo da Amazon VPC com o uso de projeção de partições
<a name="vpc-flow-logs-partition-projection"></a>

Use uma instrução `CREATE TABLE` como a que se segue para criar uma tabela, particionar a tabela e preencher as partições automaticamente usando [projeção de partições](partition-projection.md). Substitua o nome da tabela `test_table_vpclogs` no exemplo pelo nome da tabela. Edite a cláusula `LOCATION` para especificar o bucket do Amazon S3 que contém os dados de log da Amazon VPC.

A instrução `CREATE TABLE` a seguir é para logs de fluxo da VPC fornecidos em um formato de particionamento em um estilo diferente do Hive. O exemplo permite a agregação de várias contas. Se você estiver centralizando logs de fluxo de VPC de diversas contas em um bucket do Amazon S3, o ID da conta deverá ser inserido no caminho do 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}"
)
```

## Exemplos de consulta para test\$1table\$1vpclogs
<a name="query-examples-vpc-logs-pp"></a>

Os exemplos de consulta a seguir consultam a `test_table_vpclogs` criada pela instrução `CREATE TABLE` anterior. Substitua `test_table_vpclogs` nas consultas pelo nome de sua própria tabela. Modifique os valores das colunas e outras variáveis de acordo com os seus requisitos.

Para retornar as primeiras 100 entradas de log de acesso em ordem cronológica para o período de tempo especificado, execute uma consulta como a que se segue.

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

Para ver qual servidor recebe os dez principais pacotes HTTP para um período de tempo especificado, execute uma consulta como a que se segue. A consulta conta o número de pacotes recebidos na porta HTTPS 443, agrupa-os por endereço IP de destino e retorna as 10 principais entradas da semana anterior.

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

Para retornar os logs que foram criados durante um período de tempo especificado, execute uma consulta como a que se segue.

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

Para retornar os logs de acesso de um endereço IP de origem em um determinado intervalo de tempo, execute uma consulta como a que se segue.

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

Para listas as conexões TCP rejeitadas, execute uma consulta como a que se segue.

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

Para retornar os logs de acesso para o intervalo de endereços IP que começa com `10.117`, execute uma consulta como a que se segue.

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

Para retornar os logs de acesso para um endereço IP de destino em um determinado intervalo de tempo, execute uma consulta como a que segue.

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

# Criar tabelas para logs de fluxo no formato do Apache Parquet com o uso de projeção de partições
<a name="vpc-flow-logs-partition-projection-parquet-example"></a>

A instrução `CREATE TABLE` de projeção de partições para logs de fluxo da VPC a seguir está no formato do Apache Parquet, não é compatível com o Hive e é particionada por hora e por data, em vez de por dia. Substitua o nome da tabela `test_table_vpclogs_parquet` no exemplo pelo nome da tabela. Edite a cláusula `LOCATION` para especificar o bucket do Amazon S3 que contém os dados de log da 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}"
)
```

# Recursos adicionais
<a name="query-examples-vpc-logs-additional-resources"></a>

Para obter mais informações sobre como usar o Athena para analisar logs de fluxo de VPC, consulte as postagens do blog de AWS big data a seguir:
+ [Analyze VPC Flow Logs with point-and-click Amazon Athena integration](https://aws.amazon.com/blogs/networking-and-content-delivery/analyze-vpc-flow-logs-with-point-and-click-amazon-athena-integration/) (Análise de logs de fluxo de VPC com a integração de apontar e clicar do Amazon Athena) 
+ [Como analisar logs de fluxo do VPC usando o Amazon Athena e o 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/) (Otimização da performance e redução dos custos de análise de rede com os logs de fluxo de VPC no formato Apache Parquet)

# Consultar logs do AWS WAF
<a name="waf-logs"></a>

O AWS WAF é um firewall para aplicações Web que permite monitorar e controlar as solicitações HTTP e HTTPS que as aplicações Web protegidas recebem dos clientes. Você define como lidar com as solicitações da Web configurando regras dentro de uma lista de controle de acesso (ACL) da Web do AWS WAF. Depois, você protege uma aplicação Web associando a ela uma ACL da Web. Exemplos de recursos de aplicações Web que você pode proteger com o AWS WAF incluem distribuições do Amazon CloudFront, APIs REST do Amazon API Gateway e Application Load Balancers. Para obter mais informações sobre o AWS WAF, consulte [AWS WAF](https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html) no *AWS WAF Developer Guide*.

Os logs do AWS WAF incluem informações sobre o tráfego que é analisado pela sua ACL da Web, como a hora em que o AWS WAF recebeu a solicitação do recurso da AWS, os detalhes da solicitação e a ação para a regra correspondente de cada solicitação.

Você pode configurar uma ACL da Web do AWS WAF para publicar logs em um de vários destinos, onde você pode consultá-los e visualizá-los. Para obter mais informações sobre a configuração de registro em log de ACL da Web e sobre o conteúdo dos logs do AWS WAF, consulte [Logging AWS WAF web ACL traffic](https://docs.aws.amazon.com/waf/latest/developerguide/logging.html) no *AWS WAF developer guide*.

Para obter informações sobre como usar o Athena para analisar logs do AWS WAF para obter informações sobre a detecção de ameaças e possíveis ataques à segurança, consulte a postagem do blog Networking & Content Delivery da AWS [Como usar as consultas do Amazon Athena para analisar logs do AWS WAF e fornecer a visibilidade necessária para a detecção de ameaças](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/).

Para ver um exemplo de como agregar os logs do AWS WAF em um repositório central de data lake e consultá-los no Athena, leia a publicação em AWS Big Data Blog: [Analyzing AWS WAF logs with OpenSearch Service, Amazon Athena, and QuickSight](https://aws.amazon.com/blogs/big-data/analyzing-aws-waf-logs-with-amazon-es-amazon-athena-and-amazon-quicksight/).

Este tópico fornece exemplos de instruções `CREATE TABLE` para projeção de partições, particionamento manual e uma que não usa nenhum particionamento.

**nota**  
As instruções `CREATE TABLE` neste tópico podem ser usadas para logs do AWS WAF v1 e v2. Na v1, o campo `webaclid` contém um ID. Na v2, o campo `webaclid` contém um ARN completo. As instruções `CREATE TABLE` aqui tratam esse conteúdo de forma agnóstica usando o tipo de dados `string`.

**Topics**
+ [Criar uma tabela para logs do S3 do AWS WAF no Athena usando a projeção de partições](create-waf-table-partition-projection.md)
+ [Criar uma tabela para logs do S3 do AWS WAF no Athena usando a partição manual](create-waf-table-manual-partition.md)
+ [Criar uma tabela para logs do AWS WAF sem particionamento](create-waf-table.md)
+ [Consultas de exemplo para logs do AWS WAF](query-examples-waf-logs.md)

# Criar uma tabela para logs do S3 do AWS WAF no Athena usando a projeção de partições
<a name="create-waf-table-partition-projection"></a>

Como os logs do AWS WAF têm uma estrutura conhecida com um esquema de partição que você pode especificar antecipadamente, é possível reduzir o runtime das consultas e automatizar o gerenciamento de partições usando o recurso de [projeção de partições](partition-projection.md) do Athena. A projeção de partições adiciona automaticamente novas partições à medida que os dados são adicionados. Isso elimina a necessidade de adicionar manualmente as partições usando `ALTER TABLE ADD PARTITION`. 

A instrução de exemplo `CREATE TABLE` a seguir usa automaticamente a projeção de partições com base nos logs do AWS WAF desde uma data especificada até o dia de hoje para diferentes regiões da AWS. A cláusula `PARTITION BY` neste exemplo particiona por região e data, mas você pode modificá-la de acordo com seus requisitos. Modifique os campos conforme necessário para corresponder à saída do log. Nas cláusulas `LOCATION` e `storage.location.template`, substitua os espaços reservados *amzn-s3-demo-bucket* e *AWS\$1ACCOUNT\$1NUMBER* por valores que identifiquem o local do bucket do Amazon S3 dos seus logs do AWS WAF. Em ‭`projection.day.range`‬, substitua ‭*2021‭*/‭*01‭*‬/‭*01‭*‬ pela data de início que você desejar usar. Depois que você executar a consulta com êxito, poderá consultar a tabela. Você não precisa executar `ALTER TABLE ADD PARTITION` para carregar as partições. 

```
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**  
O formato do caminho na cláusula `LOCATION` no exemplo corresponde ao padrão, mas pode variar com base na configuração AWS WAF implementada. Por exemplo, o exemplo de caminho de log do AWS WAF a seguir é para uma distribuição do CloudFront:   

```
s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/cloudfronyt/2025/01/01/00/00/
```
Se você tiver problemas ao criar ou consultar sua tabela de logs do AWS WAF, confirme a localização de seus dados de log ou [entre em contato com o Suporte](https://console.aws.amazon.com/support/home/).

Para obter mais informações sobre projeção de partições, consulte [Usar projeção de partições com o Amazon Athena](partition-projection.md).

# Criar uma tabela para logs do S3 do AWS WAF no Athena usando a partição manual
<a name="create-waf-table-manual-partition"></a>

Esta seção descreve como criar uma tabela para logs do AWS WAF usando a partição manual.

Nas cláusulas `LOCATION` e `storage.location.template`, substitua os espaços reservados *amzn-s3-demo-bucket* e *AWS\$1ACCOUNT\$1NUMBER* por valores que identifiquem o local do bucket do Amazon S3 dos seus logs do 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/'
```

# Criar uma tabela para logs do AWS WAF sem particionamento
<a name="create-waf-table"></a>

Esta seção descreve como criar uma tabela para logs do AWS WAF sem particionamento ou projeção de partição.

**nota**  
Por motivos de desempenho e custo, não recomendamos usar o esquema não particionado para consultas. Para obter mais informações, consulte [Top 10 Performance Tuning Tips for Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/) (As 10 melhores dicas para ajustar o desempenho do Amazon Athena) no AWS Big Data Blog.

**Como criar a tabela de AWS WAF**

1. Copie e cole a instrução DDL a seguir no console do Athena. Modifique os campos conforme necessário para corresponder à saída do log. Modifique o valor de `LOCATION` do bucket do Amazon S3 de forma que ele corresponda a uma localização que armazena seus logs.

   Essa consulta usa o [OpenX JSON SerDe](openx-json-serde.md).
**nota**  
O SerDe espera que cada documento JSON esteja em uma única linha de texto, sem caracteres de terminação de linha separando os campos no registro. Se o texto JSON estiver formatado para impressão, você poderá receber uma mensagem de erro como HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object (HIVE\$1CURSOR\$1ERROR: a linha não é um objeto JSON válido) ou HIVE\$1CURSOR\$1ERROR: JsonParseException: Unexpected end-of-input: expected close marker for OBJECT (HIVE\$1CURSOR\$1ERROR: JSONParseException: Fim de entrada inesperado: marcador de fechamento esperado para OBJECT) quando tentar consultar a tabela após criá-la. Para obter mais informações, consulte [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) na documentação do OpenX SerDe no 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. Execute a instrução `CREATE EXTERNAL TABLE` no editor de consultas do console do Athena. Isso registra a tabela `waf_logs` e disponibiliza os dados dela para consultas no Athena.

# Consultas de exemplo para logs do AWS WAF
<a name="query-examples-waf-logs"></a>

Muitos dos exemplos de consultas nesta seção usam a tabela de projeção de partições criada anteriormente. Modifique o nome da tabela, os valores das colunas e outras variáveis de acordo com os seus requisitos. Para melhorar a performance das suas consultas e reduzir os custos, adicione a coluna de partição à condição de filtro.

**Topics**
+ [Contar indicadores, endereços IP ou regras correspondentes](query-examples-waf-logs-count.md)
+ [Consultar usando data e hora](query-examples-waf-logs-date-time.md)
+ [Consultar solicitações ou endereços bloqueados](query-examples-waf-logs-blocked-requests.md)

# Contar indicadores, endereços IP ou regras correspondentes
<a name="query-examples-waf-logs-count"></a>

Os exemplos nesta seção consultam contagens de itens de log de 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  – Contar o número de indicadores que contêm um termo especificado**  
A consulta a seguir conta o número de indicadores que contêm o termo “amazon” para o intervalo de datas especificado.  

```
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  – Contar todos os endereços IP que corresponderam a regras excluídas nos últimos 10 dias**  
A consulta a seguir conta o número de vezes nos últimos 10 dias que o endereço IP correspondeu à regra excluída no grupo de regras.   

```
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  – Agrupar todas as regras gerenciadas contadas pelo número de vezes de correspondência**  
Se você definiu as ações de regras do grupo de regras como Count na configuração de ACL da Web antes de 27 de outubro de 2022, o AWS WAF salvou suas substituições no JSON da ACL da Web como `excludedRules`. Agora, a configuração JSON para substituir uma regra para Count está nas configurações `ruleActionOverrides`. Para obter mais informações, consulte [Substituições de ações em grupos de regras](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-rule-group-override-options.html) no *Guia do desenvolvedor do AWS WAF*. Para extrair regras gerenciadas no modo Count da nova estrutura de logs, consulte `nonTerminatingMatchingRules` na seção `ruleGroupList` em vez do campo `excludedRules`, como no exemplo a seguir.  

```
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  – Agrupar todas as regras personalizadas contadas pelo número de vezes de correspondência**  
A consulta a seguir agrupa todas as regras personalizadas contadas pelo número de vezes de correspondência.  

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

Para obter informações sobre os locais de log de regras personalizadas e grupos de regras gerenciados, consulte [Monitoramento e ajuste](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-testing-activities.html) no *Guia do desenvolvedor do AWS WAF*.

# Consultar usando data e hora
<a name="query-examples-waf-logs-date-time"></a>

Os exemplos desta seção incluem consultas que usam valores de data e hora.
+ [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  – Retornar o campo de carimbo de data/hora no formato ISO 8601 legível**  
A consulta a seguir usa as funções `from_unixtime` e `to_iso8601` para retornar o campo `timestamp` no formato ISO 8601 legível (por exemplo, `2019-12-13T23:40:12.000Z` em vez de `1576280412771`). A consulta também retorna o nome, o ID e a solicitação da fonte HTTP.   

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

**Example  – Retornar os registros das últimas 24 horas**  
A consulta a seguir usa um filtro na cláusula `WHERE` para retornar o nome, o ID e os campos de solicitação da fonte HTTP dos registros nas últimas 24 horas.  

```
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  – Retornar os registros para um intervalo de datas e endereço IP especificados**  
A consulta a seguir lista os registros em um intervalo de datas especificado para um endereço IP de cliente especificado.  

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

**Example  – Para um intervalo de datas especificado, contar o número de endereços IP em intervalos de cinco minutos**  
A consulta a seguir conta, durante um determinado intervalo de datas, o número de endereços IP em intervalos de cinco minutos.  

```
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  – Contar o número de X-Forwarded-For IP nos últimos 10 dias**  
A consulta a seguir filtra os cabeçalhos de solicitação e conta o número de X-Forwarded-For IP nos últimos 10 dias.  

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

Para obter mais informações sobre as funções de data e hora, consulte [Date and Time Functions and Operators](https://trino.io/docs/current/functions/datetime.html) (Funções e operadores de data e hora) na documentação do Trino.

# Consultar solicitações ou endereços bloqueados
<a name="query-examples-waf-logs-blocked-requests"></a>

Os exemplos desta seção consultam solicitações ou endereços bloqueados.
+ [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  – Extrair os 100 primeiros endereços IP bloqueados por um tipo de regra especificado**  
A consulta a seguir extrai e conta os 100 primeiros endereços IP que foram bloqueados pela regra de encerramento `RATE_BASED` durante o intervalo de datas especificado.  

```
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  – Contar o número de vezes que uma solicitação foi bloqueada de um país especificado**  
A consulta a seguir conta o número de vezes que a solicitação chegou de um endereço IP pertencente à Irlanda (IE) e foi bloqueada pela regra de encerramento `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  – Contar o número de vezes que uma solicitação foi bloqueada, agrupando por atributos específicos**  
A consulta a seguir conta o número de vezes que a solicitação foi bloqueada, com resultados agrupados por WebACL, RuleId, ClientIP e HTTP Request URI.  

```
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  – Contar o número de vezes em que houve correspondência com um ID de regra de encerramento específico**  
A consulta a seguir conta o número de vezes que um ID de regra de encerramento específico foi correspondido (`WHERE terminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'`). A consulta agrupa os resultados por WebACL, Action, ClientIP e HTTP Request URI.  

```
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  – Recuperar os 100 primeiros endereços IP bloqueados durante um intervalo de datas especificado**  
A consulta a seguir extrai os 100 primeiros endereços IP que foram bloqueados durante um intervalo de datas especificado. A consulta também lista o número de vezes que os endereços IP foram bloqueados.  

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

Para obter informações sobre a consulta de logs do Amazon S3, veja os seguintes tópicos:
+ [Como analisar os logs de acesso do servidor do Amazon S3 usando o Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/analyze-logs-athena/) na Central de Conhecimento da AWS
+ [Consultar os logs de acesso do Amazon S3 para solicitações usando o Amazon Athena](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-s3-access-logs-to-identify-requests.html#querying-s3-access-logs-for-requests) no Guia do usuário do Amazon Simple Storage Service
+ [Usar o AWS CloudTrail para identificar solicitações do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/cloudtrail-request-identification.html) no Guia do usuário do Amazon Simple Storage Service