

# 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).