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.

Interroger les données de S3 Storage Lens à l'aide d'outils d'analyse

Avant de pouvoir interroger les données S3 Storage Lens exportées vers des tables S3 à l'aide de services AWS d'analyse tels qu'Amazon Athena ou Amazon EMR, vous devez activer l'intégration des analyses sur le compartiment de tables « aws-s3 » AWS géré et configurer les autorisations. AWS Lake Formation

Conditions préalables

Avant de commencer, assurez-vous que vous disposez des éléments suivants :

Présentation de l’intégration

Pour obtenir des informations détaillées sur l'intégration des tables S3 aux services AWS d'analyse, notamment les prérequis, la configuration des rôles IAM et les procédures étape par étape, consultez la section Intégration des tables Amazon S3 aux services AWS d'analyse.

Après avoir activé l'exportation des tables S3 et configuré l'intégration des analyses, vous pouvez interroger vos données S3 Storage Lens à l'aide de services AWS d'analyse tels qu'Amazon Athena, Amazon Redshift et Amazon EMR. Cela vous permet d'effectuer des analyses personnalisées, de créer des tableaux de bord et d'obtenir des informations à partir de vos données de stockage à l'aide du langage SQL standard.

Effectuer des requêtes avec Amazon Athena

Amazon Athena est un service de requête interactif sans serveur qui facilite l'analyse des données à l'aide du langage SQL standard. Procédez comme suit pour interroger les données S3 Storage Lens dans Athena.

Exemple : interrogez les principaux consommateurs de stockage

La requête suivante identifie les 10 principaux compartiments en termes de consommation de stockage :

SELECT 
    bucket_name,
    storage_class,
    SUM(storage_bytes) / POWER(1024, 3) AS storage_gb,
    SUM(object_count) AS objects
FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."default_storage_metrics"
WHERE report_time = (
    SELECT MAX(report_time) 
    FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."default_storage_metrics"
)
    AND record_type = 'BUCKET'
    AND bucket_name != ''
GROUP BY bucket_name, storage_class
ORDER BY storage_gb DESC
LIMIT 10

Exemple : analyse de la croissance du stockage au fil du temps

La requête suivante analyse la croissance du stockage au cours des 30 derniers jours :

SELECT 
    CAST(report_time AS date) AS report_date,
    SUM(storage_bytes) / POWER(1024, 3) AS total_storage_gb
FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."default_storage_metrics"
WHERE report_time >= current_date - interval '30' day
    AND record_type = 'ACCOUNT'
GROUP BY CAST(report_time AS date)
ORDER BY report_date DESC;

Exemple : identifier les chargements partitionnés incomplets

La requête suivante permet de trouver des compartiments contenant des téléchargements partitionnés incomplets datant de plus de 7 jours :

SELECT 
    bucket_name,
    SUM(incomplete_mpu_storage_older_than_7_days_bytes) / POWER(1024, 3) AS wasted_storage_gb,
    SUM(incomplete_mpu_object_older_than_7_days_count) AS wasted_objects
FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."default_storage_metrics"
WHERE report_time = (
    SELECT MAX(report_time) 
    FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."default_storage_metrics"
)
    AND record_type = 'BUCKET'
    AND incomplete_mpu_storage_older_than_7_days_bytes > 0
GROUP BY bucket_name
ORDER BY wasted_storage_gb DESC;

Exemple : trouver des candidats pour les données froides

La requête suivante identifie les préfixes qui n'ont pas été actifs au cours des 100 derniers jours et qui sont stockés dans des niveaux de stockage à chaud :

WITH recent_activity AS (
    SELECT DISTINCT 
        bucket_name,
        record_value AS prefix_path
    FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."expanded_prefixes_activity_metrics"
    WHERE report_time >= current_date - interval '100' day
        AND record_type = 'PREFIX'
        AND all_request_count > 0
)
SELECT 
    s.bucket_name,
    s.record_value AS prefix_path,
    s.storage_class,
    SUM(s.storage_bytes) / POWER(1024, 3) AS storage_gb
FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."expanded_prefixes_storage_metrics" s
LEFT JOIN recent_activity r 
    ON s.bucket_name = r.bucket_name 
    AND s.record_value = r.prefix_path
WHERE s.report_time = (
    SELECT MAX(report_time) 
    FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."expanded_prefixes_storage_metrics"
)
    AND s.record_type = 'PREFIX'
    AND s.storage_class IN ('STANDARD', 'REDUCED_REDUNDANCY')
    AND s.storage_bytes > 1073741824  -- > 1GB
    AND r.prefix_path IS NULL  -- No recent activity
GROUP BY s.bucket_name, s.record_value, s.storage_class
ORDER BY storage_gb DESC
LIMIT 20;

Exemple : analyse des modèles de demandes

La requête suivante analyse les modèles de demandes pour comprendre la fréquence d'accès :

SELECT 
    bucket_name,
    SUM(all_request_count) AS total_requests,
    SUM(get_request_count) AS get_requests,
    SUM(put_request_count) AS put_requests,
    ROUND(100.0 * SUM(get_request_count) / NULLIF(SUM(all_request_count), 0), 2) AS get_percentage,
    SUM(downloaded_bytes) / POWER(1024, 3) AS downloaded_gb
FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."default_activity_metrics"
WHERE report_time >= current_date - interval '7' day
    AND record_type = 'BUCKET'
    AND bucket_name != ''
GROUP BY bucket_name
HAVING SUM(all_request_count) > 0
ORDER BY total_requests DESC
LIMIT 10;

Effectuer des requêtes avec Apache Spark sur Amazon EMR

Amazon EMR fournit un framework Hadoop géré qui facilite le traitement de grandes quantités de données à l'aide d'Apache Spark. Vous pouvez utiliser le connecteur Iceberg pour lire directement les tableaux S3 Storage Lens.

Lire les tableaux S3 avec Spark

Utilisez le code Python suivant pour lire les données S3 Storage Lens avec Spark :

from pyspark.sql import SparkSession

spark = SparkSession.builder \
    .appName("S3StorageLensAnalysis") \
    .config("spark.sql.catalog.s3tablescatalog", "org.apache.iceberg.spark.SparkCatalog") \
    .config("spark.sql.catalog.s3tablescatalog.catalog-impl", "org.apache.iceberg.aws.glue.GlueCatalog") \
    .getOrCreate()

# Read S3 Storage Lens data
df = spark.read \
    .format("iceberg") \
    .load("s3tablescatalog/aws-s3.lens_my-config_exp.default_storage_metrics")

# Analyze data
df.filter("record_type = 'BUCKET'") \
    .groupBy("bucket_name", "storage_class") \
    .sum("storage_bytes") \
    .orderBy("sum(storage_bytes)", ascending=False) \
    .show(10)

Meilleures pratiques en matière d'optimisation des requêtes

Suivez ces bonnes pratiques pour optimiser les performances des requêtes et réduire les coûts :

Exemple de modèle de requête optimisé

La requête suivante présente les meilleures pratiques d'optimisation :

SELECT 
    bucket_name,
    SUM(storage_bytes) / POWER(1024, 3) AS storage_gb
FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."default_storage_metrics"
WHERE report_time >= current_date - interval '7' day  -- Date filter
    AND record_type = 'BUCKET'                         -- Record type filter
    AND storage_bytes > 0                              -- Non-empty filter
    AND bucket_name != ''                              -- Non-empty filter
GROUP BY bucket_name
ORDER BY storage_gb DESC
LIMIT 100;                                             -- Result limit

Résolution des problèmes

La requête ne renvoie aucun résultat

Problème : votre requête se termine correctement mais ne renvoie aucun résultat.

Solution :

Erreurs d’accès refusé

Problème : vous recevez des erreurs d'accès refusé lors de l'exécution de requêtes.

Solution : vérifiez que AWS Lake Formation les autorisations sont correctement configurées. Pour plus d'informations, consultez la section Intégration des tables Amazon S3 aux services AWS d'analyse.

Étapes suivantes