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.

Interrogation des 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 S3 Tables à l'aide de services AWS d'analyse tels qu'Amazon Athena ou Amazon EMR, vous devez activer l'intégration des analyses dans le compartiment de table « aws-s3 » AWS géré par -managed et configurer les autorisations. AWS Lake Formation

Conditions préalables

Avant de commencer, assurez-vous d'avoir :

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 step-by-step les procédures, 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 de tirer des informations de vos données de stockage à l'aide du 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 compartiments les plus utilisés 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 téléchargements partitionnés incomplets

La requête suivante permet de trouver des buckets contenant des 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 des données non traitées

La requête suivante identifie les préfixes sans activité au cours des 100 derniers jours 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 : analyser les 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;

Interrogation 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 tables S3 Storage Lens.

Lisez les tables 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)

Bonnes pratiques 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 illustre les meilleures pratiques en matière 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 messages d'erreur de refus d'accès 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