

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.

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