

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Interrogez les CloudFront journaux d'Amazon
<a name="cloudfront-logs"></a>

Vous pouvez configurer Amazon CloudFront CDN pour exporter les journaux d'accès à la distribution Web vers Amazon Simple Storage Service. Utilisez ces journaux pour explorer les habitudes de navigation des utilisateurs sur les propriétés Web que vous utilisez CloudFront.

Avant de commencer l'exécution de requêtes sur les journaux, activez le journal d'accès aux distributions web sur votre distribution CloudFront préférée. Pour plus d'informations, consultez les [journaux d'accès](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html) dans le manuel *Amazon CloudFront Developer Guide*. Notez le compartiment Amazon S3 dans lequel enregistrer ces journaux.

**Topics**
+ [

# Création d'un tableau pour les journaux CloudFront standard (anciens)
](create-cloudfront-table-standard-logs.md)
+ [

# Créez une table pour les CloudFront journaux dans Athena à l'aide du partitionnement manuel avec JSON
](create-cloudfront-table-manual-json.md)
+ [

# Créez une table pour les CloudFront bûches dans Athena en utilisant le partitionnement manuel avec Parquet
](create-cloudfront-table-manual-parquet.md)
+ [

# Créez une table pour les CloudFront journaux dans Athena à l'aide de la projection de partitions avec JSON
](create-cloudfront-table-partition-json.md)
+ [

# Créez une table pour les CloudFront bûches dans Athena à l'aide de la projection de partitions avec Parquet
](create-cloudfront-table-partition-parquet.md)
+ [

# Création d'un tableau pour les journaux CloudFront en temps réel
](create-cloudfront-table-real-time-logs.md)
+ [

# Ressources supplémentaires
](cloudfront-logs-additional-resources.md)

# Création d'un tableau pour les journaux CloudFront standard (anciens)
<a name="create-cloudfront-table-standard-logs"></a>

**Note**  
La procédure suivante fonctionne pour les connexions d'accès à la distribution Web CloudFront. Elle ne s'applique pas aux journaux de streaming issus des distributions RTMP.

**Pour créer une table pour les champs de fichier journal CloudFront standard**

1. Copiez et collez l'exemple d'instruction DDL suivante dans l'éditeur de requête de la console Athena. L'exemple d'instruction utilise les champs du fichier journal décrits dans la section [Champs de fichier journal standard](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) du *Amazon CloudFront Developer Guide*. Modifiez l'emplacement (`LOCATION`) pour le compartiment Simple Storage Service (Amazon S3) qui stocke vos journaux. Pour plus d'informations sur l'utilisation de l'éditeur de requête, voir [Mise en route](getting-started.md).

   Cette requête spécifie `ROW FORMAT DELIMITED` et `FIELDS TERMINATED BY '\t'` pour indiquer que les champs sont délimités par des tabulations. En `ROW FORMAT DELIMITED` effet, Athéna utilise le [LazySimpleSerDe](lazy-simple-serde.md)par défaut. La colonne `date` est une séquence d'échappement avec des guillemets simples inversés (`), car il s'agit d'un mot réservé dans Athena. Pour plus d'informations, consultez [Échappement des mots-clés réservés dans les requêtes](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. Exécutez la requête dans la console Athena. Une fois que la requête est terminée, Athena enregistre la table `cloudfront_standard_logs`, de telle sorte que les données soient prêtes pour que vous puissiez émettre des requêtes.

## Exemples de requêtes
<a name="query-examples-cloudfront-logs"></a>

La requête suivante additionne le nombre d'octets servis CloudFront entre le 9 juin et le 11 juin 2018. Placez le nom de colonne de date entre guillemets doubles car c'est un mot réservé.

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

Pour éliminer les lignes en double (par exemple, les lignes vides en double) des résultats de la requête, vous pouvez utiliser l'instruction `SELECT DISTINCT`, comme dans l'exemple suivant. 

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

# Créez une table pour les CloudFront journaux dans Athena à l'aide du partitionnement manuel avec JSON
<a name="create-cloudfront-table-manual-json"></a>

**Pour créer une table pour les champs de fichier journal CloudFront standard à l'aide d'un format JSON**

1. Copiez et collez l'exemple d'instruction DDL suivante dans l'éditeur de requête de la console Athena. L'exemple d'instruction utilise les champs du fichier journal décrits dans la section [Champs de fichier journal standard](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) du *Amazon CloudFront Developer Guide*. Modifiez l'emplacement (`LOCATION`) pour le compartiment Simple Storage Service (Amazon S3) qui stocke vos journaux. 

   Cette requête utilise OpenX JSON SerDe avec les SerDe propriétés suivantes pour lire correctement les champs JSON dans 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. Exécutez la requête dans la console Athena. Une fois que la requête est terminée, Athena enregistre la table `cf_logs_manual_partition_json`, de telle sorte que les données soient prêtes pour que vous puissiez émettre des requêtes.

## Exemples de requêtes
<a name="query-examples-cloudfront-logs-manual-json"></a>

La requête suivante additionne le nombre d'octets servis CloudFront au 15 janvier 2025.

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

Pour éliminer les lignes en double (par exemple, les lignes vides en double) des résultats de la requête, vous pouvez utiliser l'instruction `SELECT DISTINCT`, comme dans l'exemple suivant. 

```
SELECT DISTINCT * FROM cf_logs_manual_partition_json
```

# Créez une table pour les CloudFront bûches dans Athena en utilisant le partitionnement manuel avec Parquet
<a name="create-cloudfront-table-manual-parquet"></a>

**Pour créer un tableau pour les champs de fichier journal CloudFront standard à l'aide du format Parquet**

1. Copiez et collez l'exemple d'instruction DDL suivante dans l'éditeur de requête de la console Athena. L'exemple d'instruction utilise les champs du fichier journal décrits dans la section [Champs de fichier journal standard](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) du *Amazon CloudFront Developer Guide*. 

   Cette requête utilise ParquetHiveSerDe les SerDe propriétés suivantes pour lire correctement les champs de parquet dans 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. Exécutez la requête dans la console Athena. Une fois que la requête est terminée, Athena enregistre la table `cf_logs_manual_partition_parquet`, de telle sorte que les données soient prêtes pour que vous puissiez émettre des requêtes.

## Exemples de requêtes
<a name="query-examples-cloudfront-logs-manual-parquet"></a>

La requête suivante additionne le nombre d'octets servis CloudFront au 19 janvier 2025.

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

Pour éliminer les lignes en double (par exemple, les lignes vides en double) des résultats de la requête, vous pouvez utiliser l'instruction `SELECT DISTINCT`, comme dans l'exemple suivant. 

```
SELECT DISTINCT * FROM cf_logs_manual_partition_parquet
```

# Créez une table pour les CloudFront journaux dans Athena à l'aide de la projection de partitions avec JSON
<a name="create-cloudfront-table-partition-json"></a>

Vous pouvez réduire le temps d’exécution des requêtes et automatiser la gestion des partitions grâce à la fonctionnalité de projection de partition Athena. La projection des partitions ajoute automatiquement de nouvelles partitions à mesure que de nouvelles données sont ajoutées. Vous n'avez donc plus besoin d'ajouter manuellement des partitions à l'aide de la commande `ALTER TABLE ADD PARTITION`.

L'exemple d'instruction CREATE TABLE suivant utilise automatiquement la projection de partition sur les CloudFront journaux d'une CloudFront distribution spécifiée jusqu'à ce qu'ils soient présents pour un seul Région AWS. Après avoir exécuté la requête avec succès, vous pouvez interroger la table.

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

Voici quelques éléments à prendre en compte concernant les propriétés utilisées dans l’exemple précédent.
+ **Nom de la table** : le nom de la table *`cloudfront_logs_pp`* est remplaçable. Vous pouvez le remplacer par le nom de votre choix.
+ **Emplacement** : modifiez `s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/` pour pointer vers votre compartiment Amazon S3.
+ **Distribution IDs** — Pour`projection.distributionid.values`, vous pouvez spécifier plusieurs distributions IDs en les séparant par des virgules. Par exemple, *<distributionID1>*, *<distributionID2>*.
+ **Plage d’années** : dans `projection.year.range`, vous pouvez définir la plage d’années en fonction de vos données. Vous pouvez ainsi l’ajuster à n’importe quelle période, comme *2025*, *2026*.
**Note**  
L’inclusion de partitions vides, telles que celles associées à des dates futures (exemple : 2025-2040), peut avoir un impact sur les performances des requêtes. La projection de partition est cependant conçue pour gérer efficacement les dates futures. Pour maintenir des performances optimales, veillez à ce que les partitions soient gérées de manière réfléchie et évitez autant que possible un nombre excessif de partitions vides.
+ **Modèle d'emplacement de stockage** : vous devez vous assurer de le mettre à jour `storage.location.template` correctement en fonction de la structure de CloudFront partitionnement et du chemin S3 suivants.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/create-cloudfront-table-partition-json.html)

  Après avoir vérifié que la structure de CloudFront partitionnement et la structure S3 correspondent aux modèles requis, mettez-les à jour `storage.location.template` comme suit :

  ```
  'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account_id/CloudFront/${distributionid}/folder2/${year}/${month}/${day}/${hour}/folder3/'
  ```
**Note**  
Une configuration correcte de `storage.location.template` est essentielle pour garantir un stockage et une récupération corrects des données.

# Créez une table pour les CloudFront bûches dans Athena à l'aide de la projection de partitions avec Parquet
<a name="create-cloudfront-table-partition-parquet"></a>

L'exemple d'instruction CREATE TABLE suivant utilise automatiquement la projection de partitions sur CloudFront les journaux dans Parquet, depuis une CloudFront distribution spécifiée jusqu'à ce qu'un seul soit présent Région AWS. Après avoir exécuté la requête avec succès, vous pouvez interroger la table.

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

Voici quelques éléments à prendre en compte concernant les propriétés utilisées dans l’exemple précédent.
+ **Nom de la table** : le nom de la table *`cloudfront_logs_pp`* est remplaçable. Vous pouvez le remplacer par le nom de votre choix.
+ **Emplacement** : modifiez `s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/` pour pointer vers votre compartiment Amazon S3.
+ **Distribution IDs** — Pour`projection.distributionid.values`, vous pouvez spécifier plusieurs distributions IDs en les séparant par des virgules. Par exemple, *<distributionID1>*, *<distributionID2>*.
+ **Plage d’années** : dans `projection.year.range`, vous pouvez définir la plage d’années en fonction de vos données. Vous pouvez ainsi l’ajuster à n’importe quelle période, comme *2025*, *2026*.
**Note**  
L’inclusion de partitions vides, telles que celles associées à des dates futures (exemple : 2025-2040), peut avoir un impact sur les performances des requêtes. La projection de partition est cependant conçue pour gérer efficacement les dates futures. Pour maintenir des performances optimales, veillez à ce que les partitions soient gérées de manière réfléchie et évitez autant que possible un nombre excessif de partitions vides.
+ **Modèle d'emplacement de stockage** : vous devez vous assurer de le mettre à jour `storage.location.template` correctement en fonction de la structure de CloudFront partitionnement et du chemin S3 suivants.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/create-cloudfront-table-partition-parquet.html)

  Après avoir vérifié que la structure de CloudFront partitionnement et la structure S3 correspondent aux modèles requis, mettez-les à jour `storage.location.template` comme suit :

  ```
  'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account_id/CloudFront/${distributionid}/folder2/${year}/${month}/${day}/${hour}/folder3/'
  ```
**Note**  
Une configuration correcte de `storage.location.template` est essentielle pour garantir un stockage et une récupération corrects des données.

# Création d'un tableau pour les journaux CloudFront en temps réel
<a name="create-cloudfront-table-real-time-logs"></a>

**Pour créer une table pour les champs du fichier journal CloudFront en temps réel**

1. Copiez et collez l'exemple d'instruction DDL suivante dans l'éditeur de requête de la console Athena. L'exemple d'instruction utilise les champs du fichier journal décrits dans la section [Journaux en temps réel](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/real-time-logs.html) du *Amazon CloudFront Developer Guide*. Modifiez l'emplacement (`LOCATION`) pour le compartiment Simple Storage Service (Amazon S3) qui stocke vos journaux. Pour plus d'informations sur l'utilisation de l'éditeur de requête, voir [Mise en route](getting-started.md).

   Cette requête spécifie `ROW FORMAT DELIMITED` et `FIELDS TERMINATED BY '\t'` pour indiquer que les champs sont délimités par des tabulations. En `ROW FORMAT DELIMITED` effet, Athéna utilise le [LazySimpleSerDe](lazy-simple-serde.md)par défaut. La colonne `timestamp` est une séquence d'échappement avec des guillemets simples inversés (`), car il s'agit d'un mot réservé dans Athena. Pour plus d'informations, consultez [Échappement des mots-clés réservés dans les requêtes](reserved-words.md).

   L’exemple suivant contient tous les champs disponibles. Vous pouvez ajouter des commentaires ou supprimer les champs dont vous n’avez pas besoin.

   ```
   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. Exécutez la requête dans la console Athena. Une fois que la requête est terminée, Athena enregistre la table `cloudfront_real_time_logs`, de telle sorte que les données soient prêtes pour que vous puissiez émettre des requêtes.

# Ressources supplémentaires
<a name="cloudfront-logs-additional-resources"></a>

Pour plus d'informations sur l'utilisation d'Athena pour interroger CloudFront les journaux, consultez les articles suivants du blog [AWS Big Data](https://aws.amazon.com/blogs/big-data/).

[Interrogez facilement Service AWS les journaux à l'aide d'Amazon Athena](https://aws.amazon.com/blogs/big-data/easily-query-aws-service-logs-using-amazon-athena/) (29 mai 2019).

[Analysez vos journaux CloudFront d'accès Amazon à grande échelle](https://aws.amazon.com/blogs/big-data/analyze-your-amazon-cloudfront-access-logs-at-scale/) (21 décembre 2018).

[Créez une architecture sans serveur pour analyser les journaux CloudFront d'accès Amazon à l'aide AWS Lambda d'Amazon Athena et d'Amazon Managed Service pour Apache](https://aws.amazon.com/blogs/big-data/build-a-serverless-architecture-to-analyze-amazon-cloudfront-access-logs-using-aws-lambda-amazon-athena-and-amazon-kinesis-analytics/) Flink (26 mai 2017).