Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Interrogazione dei dati di S3 Storage Lens con strumenti di analisi

Prima di poter interrogare i dati di S3 Storage Lens esportati in S3 Tables utilizzando servizi di AWS analisi come Amazon Athena o Amazon EMR, devi abilitare l'integrazione dell'analisi nel bucket di tabelle AWS`aws-s3` gestito e configurare le autorizzazioni. AWS Lake Formation

Prerequisiti

Prima di iniziare, assicurati di avere:

Panoramica dell’integrazione

Per informazioni dettagliate sull'integrazione delle tabelle S3 con i servizi di AWS analisi, inclusi i prerequisiti, la configurazione dei ruoli IAM e step-by-step le procedure, consulta Integrazione delle tabelle Amazon S3 con i servizi di analisi. AWS

Dopo aver abilitato l'esportazione di S3 Tables e configurato l'integrazione delle analisi, puoi interrogare i dati di S3 Storage Lens utilizzando servizi di AWS analisi come Amazon Athena, Amazon Redshift e Amazon EMR. Ciò consente di eseguire analisi personalizzate, creare dashboard e ricavare informazioni dai dati di storage utilizzando SQL standard.

Interrogazioni con Amazon Athena

Amazon Athena è un servizio di query interattivo senza server che semplifica l'analisi dei dati utilizzando SQL standard. Usa i seguenti passaggi per interrogare i dati di S3 Storage Lens in Athena.

Esempio: interroga i principali consumatori di storage

La seguente query identifica i primi 10 bucket in base al consumo di storage:

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

Esempio: analizza la crescita dello storage nel tempo

La seguente query analizza la crescita dello storage negli ultimi 30 giorni:

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;

Esempio: identifica i caricamenti multiparte incompleti

La seguente query trova i bucket con caricamenti multiparte incompleti risalenti a più di 7 giorni fa:

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;

Esempio: trova candidati per i cold data

La seguente query identifica i prefissi senza attività negli ultimi 100 giorni che vengono archiviati in livelli di archiviazione a caldo:

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;

Esempio: analisi dei modelli di richiesta

La seguente query analizza i modelli di richiesta per comprendere la frequenza di accesso:

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;

Interrogazione con Apache Spark su Amazon EMR

Amazon EMR fornisce un framework Hadoop gestito che semplifica l'elaborazione di grandi quantità di dati utilizzando Apache Spark. Puoi usare il connettore Iceberg per leggere direttamente le tabelle di S3 Storage Lens.

Leggi le tabelle S3 con Spark

Usa il seguente codice Python per leggere i dati di S3 Storage Lens con 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)

Best practice per l'ottimizzazione delle query

Segui queste best practice per ottimizzare le prestazioni delle query e ridurre i costi:

Esempio di modello di interrogazione ottimizzato

La seguente query illustra le migliori pratiche per l'ottimizzazione:

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

Risoluzione dei problemi

La query non restituisce risultati

Problema: la query viene completata correttamente ma non restituisce risultati.

Soluzione::

Errori di accesso negato

Problema: ricevi errori di accesso negato durante l'esecuzione delle query.

Soluzione: verifica che AWS Lake Formation le autorizzazioni siano configurate correttamente. Per ulteriori informazioni, consulta Integrazione delle tabelle Amazon S3 AWS con i servizi di analisi.

Fasi successive