Consultar dados da Lente de Armazenamento do S3 com ferramentas de analytics

Antes de consultar dados da Lente de Armazenamento do S3 exportados para a funcionalidade Tabelas do S3 usando serviços de analytics da AWS, como o Amazon Athena ou o Amazon EMR, é necessário habilitar a integração de analytics no bucket de tabela “aws-s3” gerenciado pela AWS e configurar permissões do AWS Lake Formation.

Pré-requisitos

Antes de começar, verifique se você tem:

Visão geral da integração

Para ter informações detalhadas sobre como integrar a funcionalidade Tabelas do S3 a serviços de analytics da AWS, bem como sobre pré-requisitos, configuração do perfil do IAM e procedimentos passo a passo, consulte Integrar a funcionalidade Tabelas do Amazon S3 a serviços de analytics da AWS

Depois de habilitar a exportação para Tabelas do S3 e configurar a integração de analytics, você pode consultar os dados da Lente de Armazenamento do S3 usando serviços de analytics da AWS, como Amazon Athena, Amazon Redshift e Amazon EMR. Isso permite que você realize análises personalizadas, crie painéis e extraia insights dos dados de armazenamento usando SQL padrão.

Consultar com o Amazon Athena

O Amazon Athena é um serviço de consultas interativas sem servidor que facilita a análise de dados usando SQL padrão. Use as etapas a seguir para consultar dados da Lente de Armazenamento do S3 no Athena.

Exemplo: consultar os principais consumidores de armazenamento

A seguinte consulta identifica os dez buckets principais por consumo de armazenamento:

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

Exemplo: analisar o crescimento do armazenamento ao longo do tempo

A seguinte consulta analisa o crescimento do armazenamento nos últimos trinta dias:

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;

Exemplo: identificar multipart uploads incompletos

A seguinte consulta descobre buckets com multipart uploads incompletos com mais de sete dias:

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;

Exemplo: descobrir candidatos a dados pouco acessados

A seguinte consulta identifica prefixos sem atividade nos últimos cem dias que estão armazenados em níveis de armazenamento a quente:

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;

Exemplo: analisar padrões de solicitação

A seguinte consulta analisa os padrões de solicitação para entender a frequência de acesso:

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;

Consultar com o Apache Spark no Amazon EMR

O Amazon EMR disponibiliza um framework gerenciado do Hadoop que facilita o processamento de grandes quantidades de dados usando o Apache Spark. É possível usar o conector do Iceberg para ler tabelas da Lente de Armazenamento do S3 diretamente.

Ler tabelas do S3 com o Spark

Use o seguinte código Python para ler dados da Lente de Armazenamento do S3 com o 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)

Práticas recomendadas de otimização de consultas

Siga estas práticas recomendadas para otimizar o desempenho de consulta e reduzir os custos:

Exemplo de padrão de consulta otimizado

A seguinte consulta demonstra as práticas recomendadas de otimização:

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

Solução de problemas

A consulta não exibe resultados

Problema: a consulta foi concluída com êxito, mas não exibe resultados.

Solução:

Erros de acesso negado

Problema: você recebe erros de acesso negado ao executar consultas.

Solução: verifique se as permissões do AWS Lake Formation estão configuradas corretamente. Para ter mais informações, consulte Integrating Amazon S3 Tables with AWS analytics services.

Próximas etapas