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.

# Service AWS Journaux de requêtes
<a name="querying-aws-service-logs"></a>

Cette section inclut plusieurs procédures d'utilisation d'Amazon Athena pour interroger des ensembles de données courants, tels que les journaux, les CloudFront journaux Amazon AWS CloudTrail , les journaux Classic Load Balancer, les journaux Application Load Balancer, les journaux de flux Amazon VPC et les journaux Network Load Balancer.

Les tâches de cette section utilisent la console Athena, mais vous pouvez également utiliser d'autres outils comme le [pilote Athena JDBC](connect-with-jdbc.md), la [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/athena/) ou la [Référence API Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/).

Pour plus d'informations sur la AWS CloudFormation création automatique de tables de Service AWS journaux, de partitions et d'exemples de requêtes dans Athena, consultez la section [Automatisation de la création de tables de Service AWS journaux et interrogation de celles-ci avec Amazon Athena sur le blog Big](https://aws.amazon.com/blogs/big-data/automating-aws-service-logs-table-creation-and-querying-them-with-amazon-athena/) Data. AWS Pour plus d'informations sur l'utilisation d'une bibliothèque Python AWS Glue afin de créer une structure commune pour traiter les Service AWS journaux et les interroger dans Athena, [consultez la section Interrogation aisée des journaux à l'aide d' Service AWS Amazon Athena](https://aws.amazon.com/blogs/big-data/easily-query-aws-service-logs-using-amazon-athena/).

Les rubriques de cette section supposent que vous avez configuré les autorisations appropriées pour accéder à Athena et au compartiment Amazon S3 où doivent résider les données à interroger. Pour plus d’informations, consultez [Configuration de l’accès administratif et par programmation](setting-up.md) et [Mise en route](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)

# Interrogation des journaux Application Load Balancer
<a name="application-load-balancer-logs"></a>

Application Load Balancer est une option de répartition de charge pour Elastic Load Balancing qui permet la distribution du trafic dans un déploiement de microservices à l'aide de conteneurs. L'interrogation des journaux de l'Application Load Balancer vous permet de connaître la source du trafic et la latence, ainsi que les octets transférés vers et depuis les instances Elastic Load Balancing et les applications backend. Pour plus d’informations, consultez [Access logs for your Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html) et [Connection logs for your Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html) dans le *Guide d’utilisation des équilibreurs de charge Application Load Balancer*.

## Conditions préalables
<a name="application-load-balancer-logs-prerequisites"></a>
+ Activez la [journalisation des accès](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html) ou la [journalisation des connexions](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html) de sorte que les journaux Application Load Balancer puissent être enregistrés dans votre compartiment Amazon S3.
+ Une base de données pour contenir la table que vous allez créer pour Athena. Pour créer une base de données, vous pouvez utiliser l'Athena ou AWS Glue la console. Pour de plus amples informations, veuillez consulter [Création de bases de données dans Athena](creating-databases.md) dans ce guide ou [Utilisation des bases de données sur la console AWS glue](https://docs.aws.amazon.com/glue/latest/dg/console-databases.html) dans le *Guide du développeur AWS Glue *. 

**Topics**
+ [Conditions préalables](#application-load-balancer-logs-prerequisites)
+ [Création de la table des journaux d’accès ALB](create-alb-access-logs-table.md)
+ [Création de la table des journaux d’accès ALB dans Athena en utilisant la projection de partition](create-alb-access-logs-table-partition-projection.md)
+ [Exemples de requêtes pour les journaux d’accès ALB](query-alb-access-logs-examples.md)
+ [Création de la table des journaux de connexion ALB](create-alb-connection-logs-table.md)
+ [Création de la table des journaux de connexion ALB dans Athena en utilisant la projection de partition](create-alb-connection-logs-table-partition-projection.md)
+ [Exemples de requêtes pour les journaux de connexion ALB](query-alb-connection-logs-examples.md)
+ [Ressources supplémentaires](application-load-balancer-logs-additional-resources.md)

# Création de la table des journaux d’accès ALB
<a name="create-alb-access-logs-table"></a>

1. Copiez et collez l’instruction `CREATE TABLE` suivante dans l’éditeur de requêtes de la console Athena, puis modifiez-la selon vos besoins en matière d’entrée de journal. Pour plus d'informations sur le démarrage avec la console Athena, veuillez consulter la rubrique [Mise en route](getting-started.md). Remplacez le chemin indiqué dans la clause `LOCATION` par l’emplacement du dossier de vos journaux d’accès Amazon S3. Pour plus d’informations sur l’emplacement des fichiers journaux d’accès, consultez [Access log files](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-file-format) dans le *Guide d’utilisation des équilibreurs de charge Application Load Balancer*.

   Pour plus d’informations sur chaque champ des fichiers journaux, consultez la rubrique [Access log entries](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-entry-format) dans le *Guide d’utilisation des équilibreurs de charge Application Load Balancer*.
**Note**  
L’exemple d’instruction `CREATE TABLE` suivant inclut les colonnes récemment ajoutées `classification`, `classification_reason` et `conn_trace_id` (« ID de traçabilité » ou TID). Pour créer une table pour les journaux d’accès Application Load Balancer qui ne contiennent pas ces entrées, supprimez les colonnes correspondantes de l’instruction `CREATE TABLE` et modifiez l’expression régulière en conséquence. 

   ```
   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/'
   ```
**Note**  
Nous suggérons que le modèle *`?( .*)?`* à la fin du paramètre `input.regex` reste toujours en place pour gérer les futures entrées de journaux au cas où de nouveaux champs de journaux ALB seraient ajoutés. 

1. Exécutez la requête dans la console Athena. Une fois que la requête est terminée, Athena enregistre la table `alb_access_logs`, de telle sorte que les données soient prêtes pour que vous puissiez émettre des requêtes.

# Création de la table des journaux d’accès ALB dans Athena en utilisant la projection de partition
<a name="create-alb-access-logs-table-partition-projection"></a>

Étant donné que les journaux d’accès ALB possèdent une structure connue dont vous pouvez spécifier le schéma de partition à l’avance, vous pouvez réduire le temps d’exécution des requêtes et automatiser la gestion des partitions en utilisant 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 journaux d’accès ALB à partir d’une date spécifiée jusqu’au moment présent pour une seule région AWS . L'instruction se base sur l'exemple de la section précédente, mais ajoute les clauses `PARTITIONED BY` et `TBLPROPERTIES` pour activer la projection de partition. Dans les clauses `LOCATION` et `storage.location.template`, remplacez les espaces réservés par des valeurs qui identifient l’emplacement du compartiment Amazon S3 de vos journaux d’accès ALB. Pour plus d’informations sur l’emplacement des fichiers journaux d’accès, consultez [Access log files](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-file-format) dans le *Guide d’utilisation des équilibreurs de charge Application Load Balancer*. Pour`projection.day.range`, remplacez*2022*/*01*/*01*par la date de début que vous souhaitez utiliser. Après avoir exécuté la requête avec succès, vous pouvez interroger la table. Vous n'avez pas besoin d'exécuter `ALTER TABLE ADD PARTITION` pour charger les partitions. Pour plus d’informations sur chaque champ des fichiers journaux, consultez [Access log entries](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}"
            )
```

Pour plus d'informations sur la projection de partition, voir [Utilisation de la projection de partition avec Amazon Athena](partition-projection.md).

**Note**  
Nous suggérons que le modèle *?( .\$1)?* à la fin du paramètre `input.regex` reste toujours en place pour gérer les futures entrées de journaux au cas où de nouveaux champs de journaux ALB seraient ajoutés. 

# Exemples de requêtes pour les journaux d’accès ALB
<a name="query-alb-access-logs-examples"></a>

La requête suivante compte le nombre de demandes HTTP GET reçues par l'équilibreur de charge et regroupées par l'adresse IP du client:

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

Une autre requête indique les URLs visiteurs par les utilisateurs du navigateur Safari :

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

La requête suivante montre les enregistrements dont les valeurs de code d'état ELB sont supérieures ou égales à 500.

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

L'exemple suivant montre comment analyser les journaux par `datetime` :

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

La requête suivante interroge la table qui utilise la projection de partitions pour tous les journaux d’accès ALB à partir du jour spécifié.

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

# Création de la table des journaux de connexion ALB
<a name="create-alb-connection-logs-table"></a>

1. Copiez et collez l’exemple d’instruction `CREATE TABLE` suivant dans l’éditeur de requêtes de la console Athena, puis modifiez-la selon vos besoins en matière d’entrée de journal. Pour plus d'informations sur le démarrage avec la console Athena, veuillez consulter la rubrique [Mise en route](getting-started.md). Remplacez le chemin indiqué dans la clause `LOCATION` par l’emplacement du dossier de vos journaux de connexion Amazon S3. Pour plus d’informations sur l’emplacement des fichiers journaux de connexion, consultez [Connection log files](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-file-format) dans le *Guide d’utilisation des équilibreurs de charge Application Load Balancer*. Pour plus d’informations sur chaque champ des fichiers journaux, consultez [Connection log entries](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. Exécutez la requête dans la console Athena. Une fois que la requête est terminée, Athena enregistre la table `alb_connection_logs`, de telle sorte que les données soient prêtes pour que vous puissiez émettre des requêtes.

# Création de la table des journaux de connexion ALB dans Athena en utilisant la projection de partition
<a name="create-alb-connection-logs-table-partition-projection"></a>

Étant donné que les journaux de connexion ALB possèdent une structure connue dont vous pouvez spécifier le schéma de partition à l’avance, vous pouvez réduire le temps d’exécution des requêtes et automatiser la gestion des partitions en utilisant 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 journaux de connexion ALB à partir d’une date spécifiée jusqu’au moment présent pour une seule région AWS . L'instruction se base sur l'exemple de la section précédente, mais ajoute les clauses `PARTITIONED BY` et `TBLPROPERTIES` pour activer la projection de partition. Dans les clauses `LOCATION` et `storage.location.template`, remplacez les espaces réservés par des valeurs qui identifient l’emplacement du compartiment Amazon S3 de vos journaux de connexion ALB. Pour plus d’informations sur l’emplacement des fichiers journaux de connexion, consultez [Connection log files](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-file-format) dans le *Guide d’utilisation des équilibreurs de charge Application Load Balancer*. Pour`projection.day.range`, remplacez*2023*/*01*/*01*par la date de début que vous souhaitez utiliser. Après avoir exécuté la requête avec succès, vous pouvez interroger la table. Vous n'avez pas besoin d'exécuter `ALTER TABLE ADD PARTITION` pour charger les partitions. Pour plus d’informations sur chaque champ des fichiers journaux, consultez [Connection log entries](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}"
            )
```

Pour plus d'informations sur la projection de partition, voir [Utilisation de la projection de partition avec Amazon Athena](partition-projection.md).

# Exemples de requêtes pour les journaux de connexion ALB
<a name="query-alb-connection-logs-examples"></a>

La requête suivante compte les occurrences pour lesquelles la valeur de `tls_verify_status` n’a pas été `'Success'`, regroupées par adresse IP de client :

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

La requête suivante recherche les occurrences pour lesquelles la valeur de `tls_handshake_latency` a été supérieure à 2 secondes dans la plage de temps spécifiée :

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

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

Pour plus d’informations sur l’utilisation des journaux ALB, consultez les ressources suivantes.
+ [Comment analyser mes journaux d'accès Application Load Balancer avec Amazon Athena ?](https://repost.aws/knowledge-center/athena-analyze-access-logs) dans le *Centre de connaissances AWS *.
+ Pour plus d'informations sur les codes d'état HTTP dans Elastic Load Balancing, consultez la section [Résolution des problèmes de vos Application Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-troubleshooting.html) dans le *Guide de l'utilisateur des Application Load Balancers*.
+ [Cataloguez et analysez les journaux d'Application Load Balancer de manière plus efficace grâce à des classificateurs AWS Glue personnalisés et à Amazon Athena sur](https://aws.amazon.com/blogs/big-data/catalog-and-analyze-application-load-balancer-logs-more-efficiently-with-aws-glue-custom-classifiers-and-amazon-athena/) *le Big Data Blog.AWS *

# Interrogation des journaux Classic Load Balancer
<a name="elasticloadbalancer-classic-logs"></a>

Utilisez les journaux Classic Load Balancer pour analyser et comprendre les modèles de trafic en direction et en provenance des instances Elastic Load Balancing et des applications backend. Vous pouvez voir la source du trafic, la latence et les octets qui ont été transférés.

Avant d'analyser les journaux Elastic Load Balancing, configurez-les pour les enregistrer dans le compartiment Simple Storage Service (Amazon S3) de destination. Pour plus d'informations, consultez [Activation des journaux d'accès pour votre Classic Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-access-logs.html).

**Créer la table pour les journaux Elastic Load Balancing**

1. Copiez et collez l'instruction DDL suivante dans la console Athena. Vérifiez la [syntaxe](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/access-log-collection.html#access-log-entry-format) des registres du journal Elastic Load Balancing. Il se peut que vous ayez besoin de mettre à jour la requête suivante afin d'inclure les colonnes et la syntaxe d'expression régulière (Regex) pour la dernière version de l'enregistrement. 

   ```
   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. Modifiez le compartiment Simple Storage Service (Amazon S3) `LOCATION` pour spécifier la destination de vos journaux Elastic Load Balancing.

1. Exécutez la requête dans la console Athena. Une fois la requête terminée, Athena enregistre la table `elb_logs`, afin d'en préparer les données pour les requêtes. Pour de plus amples informations, veuillez consulter [Exemples de requêtes](#query-elb-classic-example).

## Exemples de requêtes
<a name="query-elb-classic-example"></a>

Utilisez une requête similaire à l'exemple suivant. Elle répertorie les serveurs d'application backend qui ont renvoyé un code de réponse d'erreur `4XX` ou `5XX`. Utilisez l'opérateur `LIMIT` pour limiter le nombre de journaux à interroger à la fois.

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

Utilisez une requête ultérieure pour résumer le temps de réponse de toutes les transactions regroupées par l'adresse IP backend et le nom d'instance 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;
```

Pour plus d'informations, consultez [Analyse de données dans S3 avec Athena](https://aws.amazon.com/blogs/big-data/analyzing-data-in-s3-using-amazon-athena/).

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

# AWS CloudTrail Journaux de requêtes
<a name="cloudtrail-logs"></a>

AWS CloudTrail est un service qui enregistre les appels AWS d'API et les événements pour les comptes Amazon Web Services. 

CloudTrail les journaux contiennent des informations sur tous les appels d'API qui vous sont adressés Services AWS, y compris à la console. CloudTrail génère des fichiers journaux chiffrés et les stocke dans Amazon S3. Pour plus d’informations, consultez le [Guide de l’utilisateur AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html). 

**Note**  
Si vous souhaitez effectuer des requêtes SQL sur des informations relatives à des CloudTrail événements concernant des comptes, des régions et des dates, pensez à utiliser CloudTrail Lake. CloudTrail Lake est une AWS alternative à la création de sentiers qui regroupe les informations d'une entreprise dans une banque de données événementielle unique et consultable. Au lieu d'utiliser le stockage par compartiment Amazon S3, il stocke les événements dans un lac de données, ce qui permet des requêtes plus riches et plus rapides. Vous pouvez l'utiliser pour créer des requêtes SQL qui recherchent des événements dans des organisations, des régions et dans des plages de temps personnalisées. Comme vous effectuez des requêtes CloudTrail Lake dans la CloudTrail console elle-même, Athena n'est pas nécessaire pour utiliser CloudTrail Lake. Pour plus d'informations, consultez la documentation de [CloudTrail Lake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html).

L'utilisation d'Athena avec CloudTrail les journaux est un moyen efficace d'améliorer votre analyse de Service AWS l'activité. Par exemple, vous pouvez utiliser des requêtes pour identifier des tendances et isoler davantage l'activité par attributs, comme l'adresse IP source ou l'utilisateur.

Une application courante consiste à utiliser des CloudTrail journaux pour analyser l'activité opérationnelle à des fins de sécurité et de conformité. Pour plus d'informations sur un exemple détaillé, consultez le billet de blog consacré au AWS Big Data intitulé [Analyser la sécurité, la conformité AWS CloudTrail et l'activité opérationnelle à l'aide d'Amazon Athena](https://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/).

Vous pouvez utiliser Athena pour exécuter des requêtes sur ces fichiers journaux directement à partir de Simple Storage Service (Amazon S3), en spécifiant l'emplacement (`LOCATION`) des fichiers journaux. Vous pouvez effectuer cette opération de deux manières :
+ En créant des tables pour les fichiers CloudTrail journaux directement depuis la CloudTrail console.
+ En créant manuellement des tables pour les fichiers CloudTrail journaux dans la console Athena.

**Topics**
+ [Comprendre les CloudTrail journaux et les tables Athena](create-cloudtrail-table-understanding.md)
+ [Utiliser la CloudTrail console pour créer une table Athena pour les journaux CloudTrail](create-cloudtrail-table-ct.md)
+ [Création d'une table pour les CloudTrail journaux dans Athena à l'aide du partitionnement manuel](create-cloudtrail-table.md)
+ [Création d’une table à des fins de suivi à l’échelle de l’organisation à l’aide du partitionnement manuel](create-cloudtrail-table-org-wide-trail.md)
+ [Créez la table pour les CloudTrail journaux dans Athena à l'aide de la projection de partitions](create-cloudtrail-table-partition-projection.md)
+ [Exemples de requêtes de CloudTrail journal](query-examples-cloudtrail-logs.md)

# Comprendre les CloudTrail journaux et les tables Athena
<a name="create-cloudtrail-table-understanding"></a>

Avant de commencer à créer des tables, vous devez en savoir un peu plus sur le stockage des données CloudTrail et sur leur mode de stockage. Cela peut vous aider à créer les tables dont vous avez besoin, que vous les créiez depuis la CloudTrail console ou depuis Athena.

CloudTrail enregistre les journaux sous forme de fichiers texte JSON au format gzip compressé (`*.json.gz`). L'emplacement des fichiers journaux dépend de la façon dont vous configurez les sentiers, Région AWS des régions dans lesquelles vous vous connectez et d'autres facteurs. 

Pour plus d'informations sur l'emplacement où les journaux sont stockés, la structure JSON et le contenu des fichiers registres, consultez les rubriques suivantes dans le [AWS CloudTrail Guide de l'utilisateur ](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) :
+  [Trouver vos fichiers CloudTrail journaux](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-find-log-files.html) 
+  [CloudTrail Exemples de fichiers journaux](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-log-file-examples.html) 
+  [CloudTrail enregistrer le contenu](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html)
+  [CloudTrail référence à un événement](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference.html) 

Pour collecter des journaux et les enregistrer sur Amazon S3, activez-les CloudTrail depuis le AWS Management Console. Pour plus d'informations, consultez la rubrique [Création d'un journal d'activité](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html) du *Guide de l'utilisateur AWS CloudTrail *.

# Utiliser la CloudTrail console pour créer une table Athena pour les journaux CloudTrail
<a name="create-cloudtrail-table-ct"></a>

Vous pouvez créer une table Athena non partitionnée pour interroger les CloudTrail journaux directement depuis la console. CloudTrail Pour créer une table Athena depuis la CloudTrail console, vous devez être connecté avec un rôle disposant des autorisations suffisantes pour créer des tables dans Athena.

**Note**  
Vous ne pouvez pas utiliser la CloudTrail console pour créer une table Athena pour les journaux de suivi des organisations. Créez plutôt la table manuellement à l'aide de la console Athena afin de pouvoir spécifier l'emplacement de stockage correct. Pour plus d'informations sur les journaux d'activité d'une organisation, consultez la rubrique [Création d'un journal d'activité pour une organisation](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/creating-trail-organization.html) du *Guide de l'utilisateur AWS CloudTrail *.
+ Pour plus d'informations sur la configuration des autorisations pour Athena, voir [Configuration de l’accès administratif et par programmation](setting-up.md).
+ Pour plus d'informations sur la création d'une table avec des partitions, consultez [Création d'une table pour les CloudTrail journaux dans Athena à l'aide du partitionnement manuel](create-cloudtrail-table.md).

**Pour créer une table Athena pour un CloudTrail sentier à l'aide de la console CloudTrail**

1. Ouvrez la CloudTrail console à l'adresse [https://console.aws.amazon.com/cloudtrail/](https://console.aws.amazon.com/cloudtrail/).

1. Dans le panneau de navigation, sélectionnez **Event history (Historique des évènements)**. 

1. Choisissez **Create Athena table** (Créer une table Athena).  
![\[Choisissez Create Athena table (Créer une table Athena)\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/cloudtrail-logs-create-athena-table.png)

1. Pour **Storage location** (Emplacement de stockage), utilisez la flèche vers le bas pour sélectionner le compartiment Simple Storage Service (Amazon S3) dans lequel les fichiers journaux sont stockés pour le journal d'activité à interroger.
**Note**  
Pour trouver le nom du bucket associé à un parcours, choisissez **Trails** dans le volet de CloudTrail navigation et consultez la colonne du **bucket S3** du parcours. Pour voir l'emplacement du compartiment dans Simple Storage Service (Amazon S3), choisissez le lien correspondant à ce compartiment dans la colonne **Compartiment S3**. Cela ouvre la console Amazon S3 à l'emplacement du CloudTrail compartiment. 

1. Choisissez **Créer un tableau**. La table est créée avec un nom par défaut qui inclut le nom du compartiment Simple Storage Service (Amazon S3).

# Création d'une table pour les CloudTrail journaux dans Athena à l'aide du partitionnement manuel
<a name="create-cloudtrail-table"></a>

Vous pouvez créer manuellement des tables pour les fichiers CloudTrail journaux dans la console Athena, puis exécuter des requêtes dans Athena.

**Pour créer une table Athena pour un CloudTrail sentier à l'aide de la console Athena**

1. Copiez et collez l’instruction DDL suivante dans l’éditeur de requêtes de la console Athena, puis modifiez-la selon vos besoins. Notez que, dans la mesure où les fichiers CloudTrail journaux ne constituent pas une trace ordonnée des appels d'API publics, les champs des fichiers journaux n'apparaissent pas dans un ordre spécifique.

   ```
   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/';
   ```
**Note**  
Nous vous suggérons d’utiliser le SerDe `org.apache.hive.hcatalog.data.JsonSerDe` indiqué dans l’exemple. Bien que a `com.amazon.emr.hive.serde.CloudTrailSerde` existe, il ne gère actuellement pas certains des nouveaux CloudTrail champs. 

1. (Facultatif) Supprimez les champs qui ne sont pas nécessaires pour votre table. Si vous ne devez lire qu'un certain ensemble de colonnes, la définition de votre table peut exclure les autres colonnes.

1. Modifiez le chemin `s3://amzn-s3-demo-bucket/AWSLogs/Account_ID/` afin de pointer vers le compartiment Amazon S3 qui contient les données des journaux que vous souhaitez interroger. Cet exemple utilise une valeur `LOCATION` des journaux pour un compte particulier, mais vous pouvez utiliser le degré de spécificité qui convient à votre application. Par exemple :
   + Pour analyser des données à partir de plusieurs comptes, vous pouvez restaurer le spécificateur `LOCATION` afin d'indiquer tous les éléments `AWSLogs` en utilisant `LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/'`.
   + Pour analyser les données correspondant à une date, un compte et une région spécifiques, utilisez `LOCATION 's3://amzn-s3-demo-bucket/123456789012/CloudTrail/us-east-1/2016/03/14/'.` 
   + Pour analyser les données d’activité du réseau plutôt que les événements de gestion, remplacez `/CloudTrail/` dans la clause `LOCATION` par `/CloudTrail-NetworkActivity/`. 

   L'utilisation du plus haut niveau dans la hiérarchie des objets vous donne la plus grande flexibilité possible lorsque vous exécutez une requête à l'aide d'Athena.

1. Vérifiez que les champs sont répertoriés correctement. Pour plus d'informations sur la liste complète des champs d'un CloudTrail enregistrement, consultez la section [Contenu de l'CloudTrail enregistrement](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html).

   L’exemple d’instruction `CREATE TABLE` indiqué à l’étape 1 utilise le SerDe [Hive JSON SerDe](hive-json-serde.md). Dans l’exemple, les champs `requestparameters`, `responseelements`, et `additionaleventdata` sont répertoriés en tant que type `STRING` dans la requête, mais le type de données `STRUCT` est utilisé dans JSON. Ainsi, pour extraire des données de ces champs, utilisez les fonctions `JSON_EXTRACT`. Pour de plus amples informations, veuillez consulter [Extraction de données JSON à partir de chaînes](extracting-data-from-JSON.md). Pour améliorer les performances, l'exemple partitionne les données par année Région AWS, mois et jour.

1. Exécutez l'instruction `CREATE TABLE` dans la console Athena.

1. Utilisez la commande [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) pour charger les partitions afin de pouvoir les interroger, comme dans l'exemple suivant.

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

# Création d’une table à des fins de suivi à l’échelle de l’organisation à l’aide du partitionnement manuel
<a name="create-cloudtrail-table-org-wide-trail"></a>

Pour créer un tableau pour les fichiers CloudTrail journaux à l'échelle de l'organisation dans Athena, suivez les étapes décrites dans la procédure suivante[Création d'une table pour les CloudTrail journaux dans Athena à l'aide du partitionnement manuel](create-cloudtrail-table.md), mais apportez les modifications indiquées dans la procédure suivante.

**Pour créer une table Athena pour les journaux à l'échelle de l'organisation CloudTrail**

1. Dans l'instruction `CREATE TABLE`, modifiez la clause `LOCATION` pour inclure l'ID de l'organisation, comme dans l'exemple suivant :

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

1. Dans la clause `PARTITIONED BY`, ajoutez une entrée pour l'ID du compte sous forme de chaîne, comme dans l'exemple suivant :

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

   L'exemple suivant montre le résultat combiné :

   ```
   ...
   
   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. Dans l'instruction `ALTER TABLE`, clause `ADD PARTITION`, incluez l'ID du compte, comme dans l'exemple suivant :

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

1. Dans l'instruction `ALTER TABLE`, clause `LOCATION`, incluez l'ID de l'organisation, l'ID du compte et la partition que vous voulez ajouter, comme dans l'exemple suivant :

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

   L'exemple suivant de l'instruction `ALTER TABLE` montre le résultat combiné :

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

Notez que dans une grande organisation, l’utilisation de cette méthode afin d’ajouter et de gérer manuellement une partition pour chaque ID de compte d’organisation peut s’avérer fastidieuse. Dans un tel scénario, pensez à utiliser CloudTrail Lake plutôt qu'Athena. CloudTrail Dans un tel scénario, le lac offre les avantages suivants :
+ Agrégation automatique des journaux dans l’ensemble de l’organisation
+ Élimination de la nécessité de configurer ou maintenir des partitions ou une table Athena
+ Les requêtes sont exécutées directement dans la CloudTrail console
+ Utilisation d’un langage de requête compatible avec SQL

Pour plus d'informations, veuillez consulter la rubrique [Utilisation de AWS CloudTrail Lake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html) dans le *Guide de l'utilisateur AWS CloudTrail *. 

# Créez la table pour les CloudTrail journaux dans Athena à l'aide de la projection de partitions
<a name="create-cloudtrail-table-partition-projection"></a>

Comme CloudTrail les journaux ont une structure connue dont vous pouvez spécifier le schéma de partition à l'avance, vous pouvez réduire le temps d'exécution des requêtes et automatiser la gestion des partitions en utilisant la fonction 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'`CREATE TABLE`instruction suivant utilise automatiquement la projection de partition sur CloudTrail les journaux à partir d'une date spécifiée jusqu'à aujourd'hui pour un enregistrement individuel Région AWS. Dans les `storage.location.template` clauses `LOCATION` et, remplacez les *aws-region* espaces réservés *bucket**account-id*, et par des valeurs identiques correspondantes. Pour`projection.timestamp.range`, remplacez*2020*/*01*/*01*par la date de début que vous souhaitez utiliser. Après avoir exécuté la requête avec succès, vous pouvez interroger la table. Vous n'avez pas besoin d'exécuter `ALTER TABLE ADD PARTITION` pour charger les partitions.

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

Pour plus d'informations sur la projection de partition, voir [Utilisation de la projection de partition avec Amazon Athena](partition-projection.md).

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

L'exemple suivant montre une partie d'une requête qui renvoie toutes les demandes anonymes (non signées) provenant de la table créée pour les journaux d' CloudTrail événements. Cette requête sélectionne ces demandes où `useridentity.accountid` est anonyme et `useridentity.arn` n'est pas spécifié :

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

Pour plus d'informations, consultez le billet de blog consacré au AWS Big Data [Analysez la sécurité, la conformité AWS CloudTrail et l'activité opérationnelle à l'aide d'Amazon Athena](https://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/).

## Interrogez les champs imbriqués dans les journaux CloudTrail
<a name="cloudtrail-logs-nested-fields"></a>

Les champs `userIdentity` et `resources` étant des types de données imbriqués, leur interrogation nécessite un traitement particulier.

L'objet `userIdentity` est constitué de types `STRUCT` imbriqués. Il est possible de les interroger en utilisant un point pour séparer les champs, comme dans l'exemple suivant :

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

Le champ `resources` est un tableau d'objets `STRUCT`. Pour ces tableaux, utilisez `CROSS JOIN UNNEST` pour désimbriquer le tableau afin de pouvoir interroger ses objets.

L'exemple suivant renvoie toutes les lignes où l'ARN de la ressource se termine par `example/datafile.txt`. Pour des raisons de lisibilité, la fonction [replace](https://prestodb.io/docs/current/functions/string.html#replace) (remplacer) supprime la sous-chaîne `arn:aws:s3:::` initiale de l'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
```

L'exemple suivant interroge les événements `DeleteBucket`. La requête extrait de l'objet `resources` le nom du compartiment et l'ID du compte auquel le compartiment appartient.

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

Pour plus d'informations sur la désimbrication, voir [Filtrage des tableaux](filtering-arrays.md).

## Conseils pour interroger CloudTrail les journaux
<a name="tips-for-querying-cloudtrail-logs"></a>

Tenez compte des points suivants lorsque vous explorez les données du CloudTrail journal :
+ Avant d'exécuter des requêtes sur ces journaux, vérifiez que votre table de journaux ressemble à celle dans [Création d'une table pour les CloudTrail journaux dans Athena à l'aide du partitionnement manuel](create-cloudtrail-table.md). Si ce n'est pas la première table, supprimez la table existante à l'aide de la commande suivante : `DROP TABLE cloudtrail_logs`.
+ Une fois que vous la table existante supprimée recréez-la. Pour de plus amples informations, veuillez consulter [Création d'une table pour les CloudTrail journaux dans Athena à l'aide du partitionnement manuel](create-cloudtrail-table.md).

  Vérifiez que les champs figurant dans votre requête Athena sont répertoriés correctement. Pour plus d'informations sur la liste complète des champs d'un CloudTrail enregistrement, consultez la section [Contenu de l'CloudTrail enregistrement](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html). 

  Si votre requête inclut des champs dans des formats JSON, par exemple `STRUCT`, extrayez les données depuis JSON. Pour de plus amples informations, veuillez consulter [Extraction de données JSON à partir de chaînes](extracting-data-from-JSON.md). 

  Quelques suggestions pour envoyer des requêtes sur votre CloudTrail table :
+ Commencez par examiner quels utilisateurs ont appelé les différentes opérations d'API et à partir de quelles adresses IP sources.
+ Utilisez la requête SQL de base suivante dans votre modèle. Collez la requête dans la console Athena et exécutez-la.

  ```
  SELECT
   useridentity.arn,
   eventname,
   sourceipaddress,
   eventtime
  FROM cloudtrail_logs
  LIMIT 100;
  ```
+ Modifiez la requête pour explorer davantage vos données.
+ Pour améliorer les performances, insérez la clause `LIMIT` pour renvoyer un sous-ensemble spécifié de lignes.

# Interrogation des journaux Amazon EMR
<a name="emr-logs"></a>

Amazon EMR et les applications de Big Data qui s'exécutent sur Amazon EMR produisent des fichiers journaux. Les fichiers journaux sont écrits sur le [nœud primaire](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html). Vous pouvez également configurer Amazon EMR pour archiver automatiquement les fichiers journaux dans Amazon S3. Vous pouvez utiliser Amazon Athena pour interroger ces journaux afin d'identifier les événements et les tendances pour les applications et les clusters. Pour plus d'informations sur les types de fichiers journaux dans Amazon EMR et leur enregistrement dans Simple Storage Service (Amazon S3), consultez la rubrique [Affichage des fichiers journaux](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-manage-view-web-log-files.html) du *Guide de gestion Amazon EMR*.

**Topics**
+ [Création et interrogation d’une table de base basée sur des fichiers journaux Amazon EMR](emr-create-table.md)
+ [Création et interrogation d’une table partitionnée basée sur des journaux Amazon EMR](emr-create-table-partitioned.md)

# Création et interrogation d’une table de base basée sur des fichiers journaux Amazon EMR
<a name="emr-create-table"></a>

L'exemple suivant crée une table de base, `myemrlogs`, basée sur les fichiers journaux enregistrés dans `s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/elasticmapreduce/`. L'emplacement Amazon S3 utilisé dans les exemples ci-dessous reflète le modèle de l'emplacement de journal par défaut pour un cluster EMR créé par un compte Amazon Web Services *123456789012* dans la région. *us-west-2* Si vous utilisez un emplacement personnalisé, le modèle est s3://amzn-s3-demo-bucket/*ClusterID*.

Pour plus d'informations sur la création d'une table partitionnée afin de potentiellement améliorer les performances des requêtes et réduire le transfert de données, consultez [Création et interrogation d’une table partitionnée basée sur des journaux 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'
```

## Exemples de requêtes
<a name="emr-example-queries-basic"></a>

Les exemples de requête suivants peuvent être exécutés sur la table `myemrlogs` créée par l'exemple précédent.

**Example – Interrogation des journaux d'étape pour les occurrences 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 – Interrogation d'un journal d'instance spécifique, i-00b3c0a839ece0a9c, pour 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 – Interrogation des journaux d'application Presto pour 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 – Interrogation des journaux d'application Namenode pour 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 – Interrogation de tous les journaux par date et heure pour 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;
```

# Création et interrogation d’une table partitionnée basée sur des journaux Amazon EMR
<a name="emr-create-table-partitioned"></a>

Ces exemples utilisent le même emplacement de journal pour créer une table Athena, mais la table est partitionnée et une partition est créée pour chaque emplacement de journal. Pour de plus amples informations, veuillez consulter [Partitionner vos données](partitions.md).

La requête suivante crée la table partitionnée nommée `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'
```

Les instructions de requête suivantes créent des partitions de table basées sur des sous-répertoires pour différents types de journaux créés par Amazon EMR dans Simple Storage Service (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/'
```

Après avoir créé les partitions, vous pouvez exécuter une requête `SHOW PARTITIONS` sur la table pour confirmer :

```
SHOW PARTITIONS mypartitionedemrlogs;
```

## Exemples de requêtes
<a name="emr-example-queries-partitioned"></a>

Les exemples suivants illustrent les requêtes pour des entrées de journal spécifiques utilisant la table et les partitions créées par les exemples ci-dessus.

**Example – Interrogation des journaux d'application application\$11561661818238\$10002 dans la partition des conteneurs pour 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 – Interrogation de la partition hadoop-Mapreduce pour la tâche job\$11561661818238\$10004 et des échecs de réduction**  

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

**Example – Interrogation des journaux Hive dans la partition de nœud pour l'ID de requête 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 – Interrogation des journaux resourcemanager dans la partition de nœud pour l'application 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
```

# Journaux AWS Global Accelerator du flux de requêtes
<a name="querying-global-accelerator-flow-logs"></a>

Vous pouvez les utiliser AWS Global Accelerator pour créer des accélérateurs qui dirigent le trafic réseau vers des points de terminaison optimaux sur le réseau AWS mondial. Pour plus d'informations sur Global Accelerator, voir [Qu'est-ce que AWS Global Accelerator](https://docs.aws.amazon.com/global-accelerator/latest/dg/what-is-global-accelerator.html).

Les journaux de flux Global Accelerator vous permettent de collecter les informations relatives au trafic de l’adresse IP entrant et sortant dans les interfaces réseau de vos accélérateurs. Les données du journal de flux sont publiées dans Simple Storage Service (Amazon S3), où vous pouvez récupérer et consulter vos données. Pour plus d'informations, consultez [Journaux de flux AWS Global Accelerator](https://docs.aws.amazon.com/global-accelerator/latest/dg/monitoring-global-accelerator.flow-logs.html).

Vous pouvez utiliser Athena pour interroger vos journaux de flux Global Accelerator en créant une table qui spécifie leur emplacement dans Simple Storage Service (Amazon S3).

**Création de la table pour les journaux de flux Global Accelerator**

1. Copiez et collez l'instruction DDL suivante dans la console Athena. Cette requête spécifie *ROW FORMAT DELIMITED* et omet de spécifier a [SerDe](serde-reference.md), ce qui signifie que la requête utilise le. [`LazySimpleSerDe`](lazy-simple-serde.md) Dans cette requête, les champs sont terminés par un espace.

   ```
   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. Modifiez la valeur `LOCATION` pour qu'elle pointe vers le compartiment Simple Storage Service (Amazon S3) qui contient vos données de journal.

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

1. Exécutez la requête dans la console Athena. Une fois la requête terminée, Athena enregistre la table `aga_flow_logs` afin de rendre les données qu’elle contient disponibles pour les requêtes.

1. Créez des partitions pour lire les données, comme dans l'exemple de requête suivant. La requête suivant crée une partition unique pour une date spécifique. Remplacez les espaces réservés de date et d'emplacement.

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

## Exemples de requêtes pour les journaux AWS Global Accelerator de flux
<a name="querying-global-accelerator-flow-logs-examples"></a>

**Example – Répertorier les demandes qui passent par un emplacement périphérique spécifique**  
L'exemple de requête suivant répertorie les demandes passées par l'emplacement périphérique LHR. Utilisez l'opérateur `LIMIT` pour limiter le nombre de journaux à interroger à la fois.  

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

**Example – Répertorier les adresses IP du point de terminaison qui reçoivent le plus grand nombre de requêtes HTTPS**  
Pour voir quelles adresses IP de point de terminaison reçoivent le plus grand nombre de requêtes HTTPS, utilisez la requête suivante. Elle comptabilise le nombre de paquets reçus sur le port HTTPS 443, les regroupe par adresse IP de destination et renvoie les 10 adresses IP principales.  

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

# Consultez les GuardDuty résultats d'Amazon
<a name="querying-guardduty"></a>

[Amazon GuardDuty](https://aws.amazon.com/guardduty/) est un service de surveillance de la sécurité qui aide à identifier les activités inattendues, potentiellement non autorisées ou malveillantes dans votre AWS environnement. Lorsqu'il détecte une activité inattendue et potentiellement malveillante, il GuardDuty génère des [résultats](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_findings.html) de sécurité que vous pouvez exporter vers Amazon S3 à des fins de stockage et d'analyse. Après avoir exporté vos résultats vers Simple Storage Service (Amazon S3), vous pouvez utiliser Athena pour les interroger. Cet article explique comment créer une table dans Athena pour vos GuardDuty résultats et les interroger.

Pour plus d'informations sur Amazon GuardDuty, consultez le [guide de GuardDuty l'utilisateur Amazon](https://docs.aws.amazon.com/guardduty/latest/ug/).

## Conditions préalables
<a name="querying-guardduty-prerequisites"></a>
+ Activez la GuardDuty fonctionnalité d'exportation des résultats vers Amazon S3. Pour connaître les étapes à suivre, consultez la section [Exportation des résultats](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_exportfindings.html) dans le guide de GuardDuty l'utilisateur Amazon.

## Créez un tableau dans Athena pour les résultats GuardDuty
<a name="querying-guardduty-creating-a-table-in-athena-for-guardduty-findings"></a>

Pour interroger vos GuardDuty conclusions auprès d'Athéna, vous devez créer un tableau pour celles-ci.

**Pour créer un tableau dans Athena pour les résultats GuardDuty**

1. Ouvrez la console à l'adresse [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Collez l'instruction DDL suivante dans la console Athena. Modifiez les valeurs `LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/account-id/GuardDuty/'` pour qu'elles correspondent à vos GuardDuty résultats dans 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')
   ```
**Note**  
Il SerDe s'attend à ce que chaque document JSON se trouve sur une seule ligne de texte sans aucun caractère de fin de ligne séparant les champs de l'enregistrement. Si le texte JSON est dans un joli format d'impression, vous pouvez recevoir un message d'erreur tel que HIVE\$1CURSOR\$1ERROR : Row is not a valid JSON Object ou HIVE\$1CURSOR\$1ERROR : : Unexpected JsonParseException end-of-input : expected close marker for OBJECT lorsque vous essayez d'interroger la table après l'avoir créée. Pour plus d'informations, consultez la section [Fichiers de données JSON](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) dans la SerDe documentation OpenX sur. GitHub 

1. Exécutez la requête dans la console Athena pour enregistrer la table `gd_logs`. Une fois la requête terminée, vous pouvez interroger les résultats à partir d'Athena.

## Exemples de requêtes
<a name="querying-guardduty-examples"></a>

Les exemples suivants montrent comment interroger les GuardDuty résultats d'Athéna.

**Example – Exfiltration de données DNS**  
La requête suivante renvoie des informations sur les EC2 instances Amazon susceptibles d'exfiltrer des données via des requêtes 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 – Accès utilisateur IAM non autorisé**  
La requête suivante renvoie tous les types de résultat `UnauthorizedAccess:IAMUser` pour un principal IAM à partir de toutes les régions.   

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

## Conseils pour interroger GuardDuty les résultats
<a name="querying-guardduty-tips"></a>

Lorsque vous créez votre requête, gardez les points suivants à l'esprit.
+ Pour extraire des données à partir de champs JSON imbriqués, utilisez les fonctions Presto `json_extract_scalar` ou `json_extract`. Pour de plus amples informations, veuillez consulter [Extraction de données JSON à partir de chaînes](extracting-data-from-JSON.md).
+ Assurez-vous que tous les caractères des champs JSON sont en minuscules.
+  Pour plus d'informations sur le téléchargement des résultats de requête, veuillez consulter [Téléchargement des fichiers de résultats des requêtes à l’aide de la console Athena](saving-query-results.md).

# AWS Network Firewall Journaux de requêtes
<a name="querying-network-firewall-logs"></a>

AWS Network Firewall est un service géré que vous pouvez utiliser pour déployer des protections réseau essentielles pour vos instances Amazon Virtual Private Cloud. AWS Network Firewall fonctionne de concert avec AWS Firewall Manager ce qui vous permet de créer des politiques basées sur des AWS Network Firewall règles, puis de les appliquer de manière centralisée à vos comptes VPCs et à vos comptes. Pour plus d'informations sur AWS Network Firewall, voir [AWS Network Firewall](https://aws.amazon.com/network-firewall/).

Vous pouvez configurer la AWS Network Firewall journalisation du trafic que vous transférez vers le moteur de règles dynamiques de votre pare-feu. La journalisation vous fournit des informations détaillées sur le trafic réseau, notamment l'heure à laquelle le moteur avec état a reçu un paquet, des informations détaillées sur le paquet et toute action de règle avec état prise à l'encontre du paquet. Les journaux sont publiés dans la destination des journaux que vous avez configurée, où vous pouvez les récupérer et les consulter. Pour plus d'informations, consultez la rubrique [Journalisation du trafic réseau à partir du AWS Network Firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html) du *Guide du développeur AWS Network Firewall *.

**Topics**
+ [Création et interrogation d’une table pour les journaux d’alertes](querying-network-firewall-logs-sample-alert-logs-table.md)
+ [Création et interrogation d’une table pour les journaux Netflow](querying-network-firewall-logs-sample-netflow-logs-table.md)

# Création et interrogation d’une table pour les journaux d’alertes
<a name="querying-network-firewall-logs-sample-alert-logs-table"></a>

1. Modifiez l’exemple d’instruction DDL suivant pour qu’il soit conforme à la structure de votre journal d’alertes. Il se peut que vous deviez mettre à jour l'instruction pour inclure les colonnes de la dernière version des journaux. Pour plus d'informations, consultez la rubrique [Contenu d'un journal de pare-feu](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html#firewall-logging-contents) du *Guide du développeur 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. Modifiez la clause `LOCATION` pour spécifier le dossier de vos journaux dans Amazon S3.

1. Exécutez votre requête `CREATE TABLE` dans l’éditeur de requête Athena. Une fois la requête terminée, Athena enregistre la table `network_firewall_alert_logs` afin que les données vers lesquelles elle pointe soient prêtes pour les interrogations.

## Exemple de requête
<a name="querying-network-firewall-logs-alert-log-sample-query"></a>

L’exemple de requête de journal d’alertes présenté dans cette section filtre les événements qui ont fait l’objet d’une inspection TLS et qui présentent des alertes d’un niveau de gravité supérieur ou égal à 2.

La requête utilise des alias pour créer des en-têtes de colonne de sortie indiquant la structure (`struct`) à laquelle appartient la colonne. Par exemple, l’en-tête de colonne du champ `event.alert.category` est `event_alert_category`, et pas simplement `category`. Pour personnaliser davantage les noms de colonne, vous pouvez modifier les alias en fonction de vos préférences. Par exemple, vous pouvez utiliser des traits de soulignement ou d’autres séparateurs pour délimiter les noms de `struct` et de champ. 

N’oubliez pas de modifier les noms de colonne et les références `struct` en fonction de la définition de votre table et des champs que vous souhaitez intégrer aux résultats de la requête.

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

# Création et interrogation d’une table pour les journaux Netflow
<a name="querying-network-firewall-logs-sample-netflow-logs-table"></a>

1. Modifiez l’exemple d’instruction DDL suivant pour qu’il soit conforme à la structure de vos journaux Netflow. Il se peut que vous deviez mettre à jour l'instruction pour inclure les colonnes de la dernière version des journaux. Pour plus d'informations, consultez la rubrique [Contenu d'un journal de pare-feu](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html#firewall-logging-contents) du *Guide du développeur 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. Modifiez la clause `LOCATION` pour spécifier le dossier de vos journaux dans Amazon S3.

1. Exécutez la requête `CREATE TABLE` dans l’éditeur de requête Athena. Une fois la requête terminée, Athena enregistre la table `network_firewall_netflow_logs` afin que les données vers lesquelles elle pointe soient prêtes pour les interrogations.

## Exemple de requête
<a name="querying-network-firewall-logs-netflow-log-sample-query"></a>

L’exemple de requête de journal Netflow présenté dans cette section filtre les événements qui ont fait l’objet d’une inspection TLS a été effectuée.

La requête utilise des alias pour créer des en-têtes de colonne de sortie indiquant la structure (`struct`) à laquelle appartient la colonne. Par exemple, l’en-tête de colonne du champ `event.netflow.bytes` est `event_netflow_bytes`, et pas simplement `bytes`. Pour personnaliser davantage les noms de colonne, vous pouvez modifier les alias en fonction de vos préférences. Par exemple, vous pouvez utiliser des traits de soulignement ou d’autres séparateurs pour délimiter les noms de `struct` et de champ. 

N’oubliez pas de modifier les noms de colonne et les références `struct` en fonction de la définition de votre table et des champs que vous souhaitez intégrer aux résultats de la requête.

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

# Interrogation des journaux du Network Load Balancer
<a name="networkloadbalancer-classic-logs"></a>

Utilisez Athena pour analyser et traiter les journaux du Network Load Balancer. Ces journaux reçoivent des informations détaillées sur les demandes TLS (Transport Layer Security, Sécurité de la couche de transport) envoyées au Network Load Balancer. Vous pouvez utiliser ces journaux d'accès pour analyser les modèles de trafic et résoudre des problèmes. 

Avant d'analyser les journaux d'accès du Network Load Balancer, activez-les et configurez-les pour les enregistrer dans le compartiment Simple Storage Service (Amazon S3) de destination. Pour plus d'informations ainsi que pour des informations sur chaque entrée du journal d'accès de Network Load Balancer, consultez [Journaux d'accès de votre Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-access-logs.html).

**Créer la table pour les journaux du Network Load Balancer**

1. Copiez et collez l'instruction DDL suivante dans la console Athena. Vérifiez la [syntaxe](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-access-logs.html#access-log-file-format) des registres du journal du Network Load Balancer. Mettez à jour l’instruction selon les besoins pour inclure les colonnes et l’expression régulière correspondant à vos enregistrements de journal.

   ```
   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. Modifiez le compartiment Simple Storage Service (Amazon S3) `LOCATION` pour spécifier la destination des journaux du Network Load Balancer.

1. Exécutez la requête dans la console Athena. Une fois la requête terminée, Athena enregistre la table `nlb_tls_logs`, afin d'en préparer les données pour les requêtes.

## Exemples de requêtes
<a name="query-nlb-example"></a>

Pour voir le nombre de fois où un certificat est utilisé, utilisez une requête similaire à l'exemple suivant :

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

La requête suivante montre combien d'utilisateurs utilisent une version de TLS antérieure à 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;
```

Utilisez la requête suivante pour identifier les connexions qui prennent beaucoup de temps pour établir des liaisons TLS :

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

Utilisez la requête suivante pour identifier et compter les versions du protocole TLS et les suites de chiffrement négociées au cours des 30 derniers jours.

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

# Interrogation des journaux de requêtes d’Amazon Route 53 Resolver
<a name="querying-r53-resolver-logs"></a>

Vous pouvez créer des tables Athena pour vos journaux de requête Amazon Route 53 Resolver et les interroger à partir d'Athena.

La journalisation des requêtes Route 53 Resolver sert à la journalisation des requêtes DNS effectuées par des ressources au sein d'un VPC, des ressources sur site qui utilisent des points de terminaison du résolveur entrant, des requêtes qui utilisent un point de terminaison du résolveur sortant pour la résolution DNS récursive et des requêtes qui utilisent des règles de pare-feu DNS Route 53 Resolver pour bloquer, autoriser ou contrôler une liste de domaines. Pour plus d'informations sur la journalisation des requêtes du résolveur, consultez la rubrique [Journalisation des requêtes du résolveur](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-query-logs.html) du *Guide du développeur Amazon Route 53*. Pour plus d'informations sur chacun des champs des journaux, consultez la rubrique [Valeurs apparaissant dans les journaux de requête du résolveur](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-query-logs-format.html) du *Guide du développeur Amazon Route 53*.

**Topics**
+ [Création de la table pour les journaux de requêtes du résolveur](querying-r53-resolver-logs-creating-the-table.md)
+ [Utiliser la projection de partition](querying-r53-resolver-logs-partitioning-example.md)
+ [Exemples de requêtes](querying-r53-resolver-logs-example-queries.md)

# Création de la table pour les journaux de requêtes du résolveur
<a name="querying-r53-resolver-logs-creating-the-table"></a>

Vous pouvez utiliser l'éditeur de requête de la console Athena pour créer et interroger une table pour vos journaux de requêtes Route 53 Resolver.

**Création et interrogation d'une table Athena pour les journaux de requêtes Route 53 Resolver**

1. Ouvrez la console à l'adresse [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Dans l'éditeur de requêtes Athena, saisissez l'instruction `CREATE TABLE` suivante. Remplacez les valeurs de la clause `LOCATION` par celles correspondant à l'emplacement de vos journaux Resolver dans Simple Storage Service (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}/'
   ```

   Les données du journal des requêtes Resolver étant au format JSON, l'instruction CREATE TABLE utilise une [ SerDebibliothèque JSON](json-serde.md) pour analyser les données.
**Note**  
Il SerDe s'attend à ce que chaque document JSON se trouve sur une seule ligne de texte sans aucun caractère de fin de ligne séparant les champs de l'enregistrement. Si le texte JSON est dans un joli format d'impression, vous pouvez recevoir un message d'erreur tel que HIVE\$1CURSOR\$1ERROR : Row is not a valid JSON Object ou HIVE\$1CURSOR\$1ERROR : : Unexpected JsonParseException end-of-input : expected close marker for OBJECT lorsque vous essayez d'interroger la table après l'avoir créée. Pour plus d'informations, consultez la section [Fichiers de données JSON](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) dans la SerDe documentation OpenX sur. GitHub 

1. Choisissez **Exécuter la requête**. L'instruction crée une table Athena nommée `r53_rlogs` dont les colonnes représentent chacun des champs de vos données de journal du résolveur.

1. Dans l'éditeur de requête de la console Athena, exécutez la requête suivante pour vérifier que votre table a été créée.

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

# Utiliser la projection de partition
<a name="querying-r53-resolver-logs-partitioning-example"></a>

L'exemple suivant montre une instruction `CREATE TABLE` pour les journaux de requête Resolver qui utilise la projection de partition et est partitionnée par VPC et par date. Pour plus d'informations sur la projection de partition, voir [Utilisation de la projection de partition avec 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}/'
)
```

# Exemples de requêtes
<a name="querying-r53-resolver-logs-example-queries"></a>

Les exemples suivants illustrent certaines requêtes que vous pouvez effectuer à partir d'Athena sur vos journaux de requêtes Resolver.

## Exemple 1 - Interrogation des journaux dans l'ordre query\$1timestamp décroissant
<a name="querying-r53-resolver-logs-example-1-query-logs-in-descending-query_timestamp-order"></a>

La requête suivante affiche les résultats du journal par ordre `query_timestamp` décroissant.

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

## Exemple 2 - Interrogation des journaux entre les heures de début et de fin spécifiées
<a name="querying-r53-resolver-logs-example-2-query-logs-within-specified-start-and-end-times"></a>

La requête suivante interroge les journaux entre minuit et 8 heures du matin le 24 septembre 2020. Remplacez les heures de début et de fin selon vos besoins.

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

## Exemple 3 - Interrogation des journaux en fonction d'un modèle de nom de requête DNS spécifié
<a name="querying-r53-resolver-logs-example-3-query-logs-based-on-a-specified-dns-query-name-pattern"></a>

La requête suivante sélectionne les registres dont le nom de requête inclut la chaîne « 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
```

## Exemple 4 - Requêtes d'interrogation des journaux sans réponse
<a name="querying-r53-resolver-logs-example-4-query-log-requests-with-no-answer"></a>

La requête suivante sélectionne les entrées du journal dans lesquelles la demande n'a pas reçu de réponse.

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

## Exemple 5 - Interrogation des journaux avec une réponse spécifique
<a name="querying-r53-resolver-logs-example-5-query-logs-with-a-specific-answer"></a>

La requête suivante montre les journaux dans lesquels la valeur `answer.Rdata` a l'adresse IP spécifiée.

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

# Interrogation des journaux d’événements Amazon SES
<a name="querying-ses-logs"></a>

Vous pouvez utiliser Amazon Athena pour interroger les journaux d’événements [Amazon Simple Email Service](https://aws.amazon.com/ses/) (Amazon SES).

Amazon SES est une plateforme de messagerie qui offre un moyen pratique et économique d'envoyer et de recevoir du courrier électronique en utilisant vos propres adresses e-mail et domaines. Vous pouvez surveiller votre activité d'envoi Amazon SES à un niveau précis à l'aide d'événements, de métriques et de statistiques.

Sur la base des caractéristiques que vous définissez, vous pouvez publier des événements Amazon SES [sur Amazon CloudWatch](https://aws.amazon.com/cloudwatch/), [Amazon Data Firehose ou](https://aws.amazon.com/kinesis/data-firehose/) [Amazon Simple Notification Service](https://aws.amazon.com/sns/). Après le stockage des informations dans Amazon S3, vous pouvez les interroger à partir d'Amazon Athena. 

Pour un exemple de `CREATE TABLE` déclaration Athena pour les journaux d'événements Amazon SES, y compris les étapes à suivre pour créer des vues et aplatir des tableaux imbriqués dans les données des journaux d'événements Amazon SES, consultez « Étape 3 : Utilisation d'Amazon Athena pour interroger les journaux d'événements SES » dans le AWS billet de blog Analyzing [Amazon SES](https://aws.amazon.com/blogs/messaging-and-targeting/analyzing-amazon-ses-event-data-with-aws-analytics-services/) event data with Analytics Services. AWS 

# Interrogation des journaux de flux Amazon VPC
<a name="vpc-flow-logs"></a>

Les journaux de flux de cloud privé virtuel Amazon Virtual Private Cloud capturent des informations sur le trafic IP circulant vers et depuis les interfaces réseau d'un VPC. Utilisez les journaux pour examiner les modèles de trafic réseau, et identifier les menaces et les risques au sein de votre réseau VPC.

Pour interroger vos journaux de flux Amazon VPC, deux options s'offrent à vous :

****
+ **Console Amazon VPC** : utilisez la fonctionnalité d'intégration Athena de la console Amazon VPC pour générer un modèle CloudFormation qui crée une base de données Athena, un groupe de travail et une table de journaux de flux avec partitionnement pour vous. Le modèle crée également un ensemble de [requêtes de journaux de flux prédéfinies](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html#predefined-queries) que vous pouvez utiliser pour obtenir des informations concernant le trafic qui passe par votre VPC.

  Pour de plus amples d'informations, consultez la section [Interroger des journaux de flux à l'aide d'Amazon Athena](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html) dans le *Guide de l'utilisateur Amazon VPC*.
+ **Console Amazon Athena** – Créez vos tables et vos requêtes directement dans la console Athena. Pour plus d'informations, continuez à lire cette page.

Avant de commencer à interroger les journaux dans Athena, [activez les journaux de flux VPC](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/flow-logs.html) et configurez-les pour qu'ils soient enregistrés dans votre compartiment Simple Storage Service (Amazon S3). Une fois que vous avez créé les journaux, laissez-les s'exécuter quelques minutes pour collecter les données. Les journaux sont créés dans un format de compression GZIP qu'Athena vous permet d'interroger directement. 

Lorsque vous créez un journal de flux VPC personnalisé, vous pouvez utiliser un format personnalisé quand vous voulez spécifier les champs à renvoyer dans le journal de flux et l'ordre dans lequel ils doivent apparaître. Pour plus d'informations sur les enregistrements des journaux de flux, consultez [Enregistrements des journaux de flux](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records) du *Guide de l'utilisateur Amazon VPC*.

## Considérations et restrictions
<a name="vpc-flow-logs-common-considerations"></a>

Lorsque vous créez des tables dans les journaux de flux Athena pour Amazon VPC, n'oubliez pas les points suivants :
+ Par défaut, sur Athena, Parquet accède aux colonnes par nom. Pour de plus amples informations, veuillez consulter [Gestion des mises à jour de schéma](handling-schema-updates-chapter.md).
+ Utilisez les noms des enregistrements du journal de flux pour les noms de colonnes sur Athena. Les noms des colonnes du schéma Athena doivent correspondre exactement aux noms des champs dans les journaux de flux Amazon VPC, avec les différences suivantes : 
  + Remplacez les traits d'union dans les noms des champs de journaux Amazon VPC par des traits de soulignement dans les noms des colonnes Athena. Pour plus d’informations sur les caractères admis dans les noms de base de données, de table et de colonne dans Athena, consultez [Attribution de noms aux tables, aux bases de données et aux colonnes](tables-databases-columns-names.md).
  + Échappez les noms des enregistrements du journal de flux qui sont [Mots-clés réservés](reserved-words.md) sur Athena en les entourant de barres obliques inversées. 
+ Les journaux de flux VPC sont Compte AWS spécifiques. Lorsque vous publiez vos fichiers journaux sur Amazon S3, le chemin créé par Amazon VPC dans Amazon S3 inclut l'ID du Compte AWS utilisé pour créer le journal de flux. Pour plus d'informations, consultez [Publier les journaux de flux vers Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-s3.html) dans le *Guide de l'utilisateur Amazon VPC*.

**Topics**
+ [Considérations et restrictions](#vpc-flow-logs-common-considerations)
+ [Création et interrogation d’une table pour les journaux de flux Amazon VPC](vpc-flow-logs-create-table-statement.md)
+ [Création de tables pour les journaux de flux au format Apache Parquet](vpc-flow-logs-parquet.md)
+ [Création et interrogation d’une table pour les journaux de flux Amazon VPC à l’aide de la projection de partitions](vpc-flow-logs-partition-projection.md)
+ [Création de tables pour les journaux de flux au format Apache Parquet à l’aide de la projection de partition](vpc-flow-logs-partition-projection-parquet-example.md)
+ [Ressources supplémentaires](query-examples-vpc-logs-additional-resources.md)

# Création et interrogation d’une table pour les journaux de flux Amazon VPC
<a name="vpc-flow-logs-create-table-statement"></a>

La procédure suivante permet de créer une table Amazon VPC pour les journaux de flux VPC. Lorsque vous créez un journal de flux avec un format personnalisé, vous créez une table avec des champs correspondant à ceux que vous avez spécifiés lors de la création du journal de flux, dans le même ordre que celui où vous les avez spécifiés.

**Pour créer une table Athena pour les journaux de flux Amazon VPC**

1. Saisissez une instruction DDL telle que la suivante dans l'éditeur de requêtes de la console Athena, en suivant les instructions de la section [Considérations et restrictions](vpc-flow-logs.md#vpc-flow-logs-common-considerations). L'exemple d'instruction suivant crée une table comportant les colonnes des journaux de flux Amazon VPC versions 2 à 5, comme indiqué dans la rubrique [Registres des journaux de flux](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records). Si vous utilisez un autre jeu de colonnes ou un autre ordre de colonnes, modifiez l'instruction en conséquence.

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

   Notez les points suivants :
   + La requête spécifie `ROW FORMAT DELIMITED` et omet de spécifier un SerDe. Cela signifie que la requête utilise le [Lazy Simple SerDe pour les fichiers CSV, TSV et délimités sur mesure](lazy-simple-serde.md). Dans cette requête, les champs sont terminés par un espace.
   + La clause `PARTITIONED BY` utilise le type `date`. Cela permet d'utiliser des opérateurs mathématiques dans les requêtes pour sélectionner ce qui est plus ancien ou plus récent par rapport à une certaine date.
**Note**  
Étant donné que `date` est un mot-clé réservé dans les instructions DDL, il est entouré de guillemets inversés. Pour de plus amples informations, veuillez consulter [Échappement des mots-clés réservés dans les requêtes](reserved-words.md).
   + Pour un journal de flux VPC avec un autre format personnalisé, modifiez les champs pour qu'ils correspondent à ceux que vous avez spécifiés lors de la création du journal de flux.

1. Modifiez le `LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/{region_code}/'` afin de pointer vers le compartiment Amazon S3 qui contient les données de vos journaux.

1. Exécutez la requête dans la console Athena. Une fois que la requête est terminée, Athena enregistre la table `vpc_flow_logs`, de telle sorte que les données soient prêtes pour que vous puissiez émettre des requêtes.

1. Créez des partitions pour être en mesure de lire les données, comme dans l'exemple de requête suivant. Cette requête suivant crée une partition unique pour une date spécifique. Remplacez les espaces réservés de date et d'emplacement en fonction des besoins. 
**Note**  
Cette requête crée seulement une partition unique, pour une date que vous spécifiez. Pour automatiser le processus, utilisez un script qui exécute cette requête et crée des partitions de cette manière pour la `year/month/day`, ou utilisez une instruction `CREATE TABLE` qui spécifie la [projection des partitions](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';
   ```

## Exemples de requêtes pour la table vpc\$1flow\$1logs
<a name="query-examples-vpc-logs"></a>

Utilisez l'éditeur de requêtes de la console Athena pour exécuter des instructions SQL sur la table que vous créez. Vous pouvez enregistrer les requêtes, afficher des requêtes précédentes ou télécharger les résultats de la requête au format CSV. Dans les exemples suivants, remplacer `vpc_flow_logs` par le nom de votre table. Modifiez les valeurs de colonne et d'autres variables en fonction de vos besoins.

L'exemple de requête suivant répertorie un maximum de 100 journaux de flux pour la date spécifiée.

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

La requête suivante répertorie toutes les connexions TCP rejetées et utilise la nouvelle colonne de partition de date, `date`, pour en extraire le jour de la semaine pendant lequel ces événements sont survenus.

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

Pour voir lequel de vos serveurs reçoit le plus grand nombre de demandes HTTPS, utilisez cette requête. Elle comptabilise le nombre de paquets reçus sur le port HTTPS 443, les regroupe par adresse IP de destination et renvoie les 10 principaux.

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

# Création de tables pour les journaux de flux au format Apache Parquet
<a name="vpc-flow-logs-parquet"></a>

La procédure suivante permet de créer une table Amazon VPC pour les journaux de flux VPC au format Apache Parquet.

**Pour créer une table Athena pour les journaux de flux Amazon VPC au format Parquet**

1. Saisissez une instruction DDL telle que la suivante dans l'éditeur de requêtes de la console Athena, en suivant les instructions de la section [Considérations et restrictions](vpc-flow-logs.md#vpc-flow-logs-common-considerations). L'exemple d'instruction suivant crée une table comportant les colonnes des journaux de flux Amazon VPC versions 2 à 5, comme indiqué dans la rubrique [Registres des journaux de flux](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records) au format Parquet, Hive partitionné heure par heure. Si vous n'avez aucune partition horaire, retirez `hour` de la clause `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. Modifiez l'exemple `LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/'` afin de pointer vers le chemin Simple Storage Service (Amazon S3) qui contient les données de vos journaux.

1. Exécutez la requête dans la console Athena.

1. Si vos données sont au format compatible Hive, exécutez la commande suivante dans la console Athena pour mettre à jour et charger les partitions Hive dans le métastore. Une fois la requête terminée, vous pouvez interroger les données dans la table `vpc_flow_logs_parquet`.

   ```
   MSCK REPAIR TABLE vpc_flow_logs_parquet
   ```

   Si vous n'utilisez pas de données compatibles avec Hive, exécutez [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) pour charger les partitions.

Pour de plus amples informations sur l'utilisation d'Athena pour interroger les journaux de flux Amazon VPC au format Parquet, veuillez consulter l'article [Optimiser les performances et réduire les coûts d'analytique réseau avec les journaux de flux VPC au format Apache Parquet](https://aws.amazon.com/blogs/big-data/optimize-performance-and-reduce-costs-for-network-analytics-with-vpc-flow-logs-in-apache-parquet-format/) dans le *Blog Big Data AWS *.

# Création et interrogation d’une table pour les journaux de flux Amazon VPC à l’aide de la projection de partitions
<a name="vpc-flow-logs-partition-projection"></a>

Utilisez une instruction `CREATE TABLE` comme la suivante pour créer une table, partitionner la table et remplir automatiquement les partitions en utilisant [projection de partition](partition-projection.md). Remplacer le nom de la table `test_table_vpclogs` dans l'exemple par le nom de votre table. Modifiez la clause `LOCATION` pour spécifier le compartiment Amazon S3 qui contient les données de vos journaux Amazon VPC.

L'instruction `CREATE TABLE` suivante concerne les journaux de flux VPC livrés dans un format de partitionnement de style non Hive. L’exemple permet l’agrégation de plusieurs comptes. Si vous centralisez les journaux de flux VPC de plusieurs comptes dans un compartiment Amazon S3, l'ID du compte doit être saisi dans le chemin d'accès 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}"
)
```

## Exemples de requêtes pour la table test\$1table\$1vpclogs
<a name="query-examples-vpc-logs-pp"></a>

L'exemple de requête suivant interroge la table `test_table_vpclogs` créée par l'instruction précédente `CREATE TABLE`. Remplacez `test_table_vpclogs` dans les requêtes par le nom de votre table. Modifiez les valeurs de colonne et d'autres variables en fonction de vos besoins.

Pour renvoyer les 100 premières entrées du journal d'accès dans l'ordre chronologique pendant une période donnée, exécutez une requête comme la suivante.

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

Pour voir quel serveur reçoit les dix premiers paquets HTTP pendant une période de temps spécifiée, exécutez une requête semblable à la suivante. La requête compte le nombre de paquets reçus sur le port HTTPS 443, les regroupe par adresse IP de destination et renvoie les 10 premières entrées de la semaine précédente.

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

Pour renvoyer les journaux créés pendant une période donnée, exécutez une requête semblable à la suivante.

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

Pour renvoyer les journaux d'accès d'une adresse IP source entre des périodes spécifiées, exécutez une requête semblable à la suivante.

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

La requête ci-dessous affiche toutes les connexions TCP rejetées.

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

Pour renvoyer les journaux d'accès de la plage d'adresses IP commençant par `10.117`, exécutez une requête similaire à la suivante.

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

Pour renvoyer les journaux d'accès d'une adresse IP de destination entre une certaine plage de temps, exécutez une requête semblable à la suivante.

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

# Création de tables pour les journaux de flux au format Apache Parquet à l’aide de la projection de partition
<a name="vpc-flow-logs-partition-projection-parquet-example"></a>

L’instruction `CREATE TABLE` de projection de partition suivante pour les journaux de flux VPC est au format Apache Parquet, elle n’est pas compatible avec Hive et elle est partitionnée par heure et par date plutôt que par jour. Remplacer le nom de la table `test_table_vpclogs_parquet` dans l'exemple par le nom de votre table. Modifiez la clause `LOCATION` pour spécifier le compartiment Amazon S3 qui contient les données de vos journaux 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}"
)
```

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

Pour plus d'informations sur l'utilisation d'Athena pour analyser les journaux de flux VPC, consultez les articles suivants du blog AWS Big Data :
+ [Analysez les journaux de flux VPC grâce à l'intégration d'Amazon point-and-click Athena](https://aws.amazon.com/blogs/networking-and-content-delivery/analyze-vpc-flow-logs-with-point-and-click-amazon-athena-integration/) 
+ [Analyse des journaux de flux VPC à l'aide d'Amazon Athena et de Quick](https://aws.amazon.com/blogs/big-data/analyzing-vpc-flow-logs-using-amazon-athena-and-amazon-quicksight/)
+ [Optimiser les performances et réduire les coûts de l'analyse des réseaux grâce aux journaux de flux VPC au format Apache Parquet](https://aws.amazon.com/blogs/big-data/optimize-performance-and-reduce-costs-for-network-analytics-with-vpc-flow-logs-in-apache-parquet-format/)

# AWS WAF Journaux de requêtes
<a name="waf-logs"></a>

AWS WAF est un pare-feu d'applications Web qui vous permet de surveiller et de contrôler les requêtes HTTP et HTTPS que vos applications Web protégées reçoivent de la part des clients. Vous définissez comment traiter les requêtes Web en configurant des règles dans une liste de contrôle d'accès AWS WAF Web (ACL). Vous protégez ensuite une application Web en lui associant une ACL Web. Parmi les ressources d'applications Web que vous pouvez protéger, AWS WAF citons les CloudFront distributions Amazon, Amazon API APIs Gateway REST et les équilibreurs de charge d'application. Pour plus d'informations AWS WAF, consultez [AWS WAF](https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html)le *guide du AWS WAF développeur*.

AWS WAF les journaux incluent des informations sur le trafic analysé par votre ACL Web, telles que l'heure à laquelle la demande AWS WAF a été reçue de votre AWS ressource, des informations détaillées sur la demande et l'action pour la règle à laquelle chaque demande correspond.

Vous pouvez configurer une ACL AWS WAF Web pour publier les journaux vers l'une des nombreuses destinations, où vous pouvez les interroger et les consulter. Pour plus d'informations sur la configuration de la journalisation des ACL Web et du contenu des AWS WAF journaux, consultez la section [Journalisation du trafic ACL AWS WAF Web](https://docs.aws.amazon.com/waf/latest/developerguide/logging.html) dans le *guide du AWS WAF développeur*.

Pour savoir comment utiliser Athena pour analyser les AWS WAF journaux afin d'obtenir des informations sur la détection des menaces et les attaques de sécurité potentielles, consultez le billet de blog consacré aux AWS réseaux et [à la diffusion de contenu Comment utiliser les requêtes Amazon Athena pour AWS WAF analyser les journaux et fournir la visibilité nécessaire à la](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/) détection des menaces.

Pour savoir comment agréger les AWS WAF journaux dans un référentiel central de lacs de données et les interroger avec Athena, consultez le billet de blog sur le AWS Big Data [Analyzing AWS WAF logs with OpenSearch Service, Amazon Athena](https://aws.amazon.com/blogs/big-data/analyzing-aws-waf-logs-with-amazon-es-amazon-athena-and-amazon-quicksight/) et Quick.

Cette rubrique fournit des exemples d’instructions `CREATE TABLE` pour la projection de partition et le partitionnement manuel, ainsi qu’un exemple qui n’utilise pas le partitionnement.

**Note**  
Les instructions `CREATE TABLE` de cette rubrique peuvent être utilisées à la fois pour les journaux AWS WAF v1 et v2. Dans v1, le champ `webaclid` contient une ID. Dans v2, le champ `webaclid` contient un ARN complet. Les instructions `CREATE TABLE` ici traitent ce contenu de manière agnostique à l'aide du type de données `string`.

**Topics**
+ [Création d'une table pour les journaux AWS WAF S3 dans Athena à l'aide de la projection de partitions](create-waf-table-partition-projection.md)
+ [Créer une table pour les journaux AWS WAF S3 dans Athena à l'aide d'une partition manuelle](create-waf-table-manual-partition.md)
+ [Création d'une table pour les AWS WAF journaux sans partitionnement](create-waf-table.md)
+ [Exemples de requêtes pour les AWS WAF journaux](query-examples-waf-logs.md)

# Création d'une table pour les journaux AWS WAF S3 dans Athena à l'aide de la projection de partitions
<a name="create-waf-table-partition-projection"></a>

Comme AWS WAF les journaux ont une structure connue dont vous pouvez spécifier le schéma de partition à l'avance, vous pouvez réduire le temps d'exécution des requêtes et automatiser la gestion des partitions en utilisant la fonction de [projection de partition](partition-projection.md) 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'`CREATE TABLE`instruction suivant utilise automatiquement la projection de partitions sur AWS WAF les journaux à partir d'une date spécifiée jusqu'à aujourd'hui pour quatre AWS régions différentes. La clause `PARTITION BY` dans cet exemple, partitionne par région et par date, mais vous pouvez modifier les partitions en fonction de vos besoins. Modifiez les champs si nécessaire pour qu'ils correspondent à la sortie de votre journal. Dans les `storage.location.template` clauses `LOCATION` et, remplacez les *AWS\$1ACCOUNT\$1NUMBER* espaces réservés *amzn-s3-demo-bucket* et par des valeurs identifiant l'emplacement du compartiment Amazon S3 dans lequel se trouvent vos AWS WAF journaux. Pour`projection.day.range`, remplacez*2021*/*01*/*01*par la date de début que vous souhaitez utiliser. Après avoir exécuté la requête avec succès, vous pouvez interroger la table. Vous n'avez pas besoin d'exécuter `ALTER TABLE ADD PARTITION` pour charger les partitions. 

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

**Note**  
Le format du chemin indiqué dans la `LOCATION` clause de l'exemple est standard mais peut varier en fonction de la AWS WAF configuration que vous avez implémentée. Par exemple, l'exemple de chemin de AWS WAF journal suivant concerne une CloudFront distribution :   

```
s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/cloudfronyt/2025/01/01/00/00/
```
Si vous rencontrez des problèmes lors de la création ou de l'interrogation de votre table de AWS WAF journaux, confirmez l'emplacement de vos données de journal ou de votre [contact Support](https://console.aws.amazon.com/support/home/).

Pour plus d'informations sur la projection de partition, voir [Utilisation de la projection de partition avec Amazon Athena](partition-projection.md).

# Créer une table pour les journaux AWS WAF S3 dans Athena à l'aide d'une partition manuelle
<a name="create-waf-table-manual-partition"></a>

Cette section décrit comment créer une table pour les AWS WAF journaux à l'aide d'une partition manuelle.

Dans les `storage.location.template` clauses `LOCATION` et, remplacez les *AWS\$1ACCOUNT\$1NUMBER* espaces réservés *amzn-s3-demo-bucket* et par des valeurs identifiant l'emplacement du compartiment Amazon S3 dans lequel se trouvent vos AWS WAF journaux.

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

# Création d'une table pour les AWS WAF journaux sans partitionnement
<a name="create-waf-table"></a>

Cette section explique comment créer une table pour les AWS WAF journaux sans partitionnement ni projection de partition.

**Note**  
Pour des raisons de performance et de coût, l’utilisation d’un schéma non partitionné pour les requêtes est déconseillée. Pour plus d'informations, consultez les [10 meilleurs conseils d'optimisation des performances pour Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/) sur le blog AWS Big Data.

**Pour créer le AWS WAF tableau**

1. Copiez et collez l'instruction DDL suivante dans la console Athena. Modifiez les champs si nécessaire pour qu'ils correspondent à la sortie de votre journal. Modifiez l'emplacement `LOCATION` pour le compartiment Amazon S3 correspondant à celui qui stocke vos journaux.

   Cette requête utilise le [OpenX JSON SerDe](openx-json-serde.md).
**Note**  
Il SerDe s'attend à ce que chaque document JSON se trouve sur une seule ligne de texte sans aucun caractère de fin de ligne séparant les champs de l'enregistrement. Si le texte JSON est dans un joli format d'impression, vous pouvez recevoir un message d'erreur tel que HIVE\$1CURSOR\$1ERROR : Row is not a valid JSON Object ou HIVE\$1CURSOR\$1ERROR : : Unexpected JsonParseException end-of-input : expected close marker for OBJECT lorsque vous essayez d'interroger la table après l'avoir créée. Pour plus d'informations, consultez la section [Fichiers de données JSON](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) dans la SerDe documentation OpenX sur. 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. Exécutez l'instruction `CREATE EXTERNAL TABLE` dans l'éditeur de requête de la console Athena. Cette opération permet d'enregistrer la table `waf_logs` et de mettre les données qu'elle contient à la disposition des requêtes d'Athena.

# Exemples de requêtes pour les AWS WAF journaux
<a name="query-examples-waf-logs"></a>

Une grande partie des exemples de requêtes utilise la table de projection de partition créée précédemment. Dans les exemples de requêtes suivants, modifiez le nom de la table, les valeurs des colonnes et les autres variables en fonction de vos besoins. Pour augmenter les performances de vos requêtes et réduire les coûts, ajoutez la colonne de partition dans la condition de filtre.

**Topics**
+ [Comptabilisation des référents, des adresses IP ou des règles correspondantes](query-examples-waf-logs-count.md)
+ [Requête utilisant la date et l’heure](query-examples-waf-logs-date-time.md)
+ [Requête portant sur des demandes ou des adresses bloquées](query-examples-waf-logs-blocked-requests.md)

# Comptabilisation des référents, des adresses IP ou des règles correspondantes
<a name="query-examples-waf-logs-count"></a>

Les exemples de cette section soumettent des requêtes de comptabilisation d’éléments d’intérêt des journaux.
+ [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 – Comptage du nombre de référents qui contiennent un terme spécifié**  
La requête suivante compte le nombre de référents qui contiennent le terme « amazon » pour la plage de dates spécifiée.  

```
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 – Comptage de toutes les adresses IP correspondant à des règles d'exclusion au cours des 10 derniers jours**  
La requête suivante compte le nombre de fois, au cours des 10 derniers jours, où l'adresse IP correspond à la règle d'exclusion dans le groupe de règles.   

```
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 – Regroupement de toutes les règles gérées comptées en fonction du nombre de fois qu'elles ont été mises en correspondance**  
Si vous avez défini les actions de règles du groupe de règles sur Count dans votre configuration ACL Web avant le 27 octobre 2022, vous AWS WAF avez enregistré vos remplacements dans le fichier JSON de l'ACL Web sous `excludedRules` le nom de. Désormais, le paramètre JSON permettant de remplacer une règle par Comptage se trouve dans les paramètres `ruleActionOverrides`. Pour plus d'informations, consultez [Remplacements d'action dans les groupes de règles](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-rule-group-override-options.html) du *Guide du développeur AWS WAF *. Pour extraire les règles gérées en mode Comptage à partir de la nouvelle structure du journal, interrogez les `nonTerminatingMatchingRules` dans la section `ruleGroupList` plutôt que le champ `excludedRules`, comme dans l'exemple suivant.  

```
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 – Regroupement de toutes les règles personnalisées comptées en fonction du nombre de fois qu'elles ont été mises en correspondance**  
La requête suivante regroupe toutes les règles personnalisées comptées en fonction du nombre de fois qu'elles ont été mises en correspondance.  

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

Pour plus d'informations sur l'emplacement des journaux pour les règles personnalisées et les groupes de règles gérés, consultez [Surveillance et réglage](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-testing-activities.html) du *Guide du développeur AWS WAF *.

# Requête utilisant la date et l’heure
<a name="query-examples-waf-logs-date-time"></a>

Les exemples fournis dans cette section présentent des requêtes qui utilisent des valeurs de date et d’heure.
+ [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 – Renvoi du champ d'horodatage au format ISO 8601 lisible par l'homme**  
La requête suivante utilise les fonctions `from_unixtime` et `to_iso8601` pour renvoyer le champ `timestamp` dans un format ISO 8601 lisible par l'homme (par exemple, `2019-12-13T23:40:12.000Z` au lieu de `1576280412771`). La requête renvoie également le nom de la source HTTP, l'ID de la source et la requête.   

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

**Example – Renvoi des enregistrements des dernières 24 heures**  
La requête suivante utilise un filtre dans la clause `WHERE` pour renvoyer les champs Nom de la source HTTP, ID de la source HTTP et Requête HTTP pour les registres des dernières 24 heures.  

```
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 – Renvoi des enregistrements pour une plage de dates et une adresse IP spécifiées**  
La requête suivante répertorie les registres dans une plage de dates spécifiée pour une adresse IP client spécifiée.  

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

**Example – Comptage du nombre d'adresses IP par intervalles de cinq minutes pour une plage de dates spécifiée**  
La requête suivante compte, pour une plage de dates particulière, le nombre d'adresses IP à intervalles de cinq minutes.  

```
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 — Comptez le nombre d' X-Forwarded-Foradresses IP au cours des 10 derniers jours**  
La requête suivante filtre les en-têtes des demandes et compte le nombre d' X-Forwarded-Foradresses IP au cours des 10 derniers jours.  

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

Pour plus d'informations sur les fonctions de date et d'heure, veuillez consulter la rubrique [Date and time functions and operators](https://trino.io/docs/current/functions/datetime.html) dans la documentation Trino.

# Requête portant sur des demandes ou des adresses bloquées
<a name="query-examples-waf-logs-blocked-requests"></a>

Les exemples fournis dans cette section présentent des requêtes portant sur des demandes ou des adresses bloquées.
+ [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 – Extraction des 100 premières adresses IP bloquées par un type de règle spécifié**  
La requête suivante extrait et compte les 100 premières adresses IP qui ont été bloquées par la règle de terminaison `RATE_BASED` pendant la période spécifiée.  

```
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 – Comptage du nombre de fois où une demande provenant d'un pays donné a été bloquée**  
La requête suivante comptabilise le nombre de fois où la demande est arrivée à partir d'une adresse IP irlandaise (IE) et a été bloquée par la règle de résiliation `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 – Comptage du nombre de fois où une demande a été bloquée, en regroupant par attributs spécifiques**  
La requête suivante compte le nombre de fois où la demande a été bloquée, les résultats étant regroupés par WebACL, RuleId ClientIP et URI de requête HTTP.  

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

**Example – Comptage du nombre de fois qu'un ID de règle de terminaison spécifique a été trouvé**  
La requête suivante comptabilise le nombre de fois où un ID de règle de résiliation spécifique a été mis en correspondance (`WHERE terminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'`). La requête regroupe ensuite les résultats par WebACL, Action, ClientIP et URI de requête HTTP.  

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

**Example – Récupération des 100 premières adresses IP bloquées pendant une plage de dates spécifiée**  
La requête suivante extrait les 100 premières adresses IP qui ont été bloquées pour une plage de dates spécifiée. La requête répertorie également le nombre de fois où les adresses IP ont été bloquées.  

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

Pour plus d'informations sur l'interrogation des journaux de Simple Storage Service (Amazon S3), consultez les rubriques suivantes :
+ [Comment analyser mes journaux d'accès au serveur Simple Storage Service (Amazon S3) avec Athena ?](https://aws.amazon.com/premiumsupport/knowledge-center/analyze-logs-athena/) dans le Centre de connaissances AWS 
+ [Interrogation des journaux d'accès Amazon S3 pour les requêtes utilisant Amazon Athena](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-s3-access-logs-to-identify-requests.html#querying-s3-access-logs-for-requests) dans le Guide de l'utilisateur Amazon Simple Storage Service
+ [Utilisation de AWS CloudTrail pour identifier les requêtes Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/cloudtrail-request-identification.html) dans le Guide de l'utilisateur Amazon Simple Storage Service