

# Consulta de datos de Lente de almacenamiento de S3 con herramientas de análisis
<a name="storage-lens-s3-tables-querying"></a>

Antes de poder consultar los datos de Lente de almacenamiento de S3 exportados a tablas de S3 mediante servicios de análisis de AWS como Amazon Athena o Amazon EMR, debe habilitar la integración de análisis en el bucket de tablas de “aws-s3” administrado de AWS y configurar los permisos de AWS Lake Formation.

**importante**  
La habilitación de la integración de los análisis en el bucket de tablas de “aws-s3” es un paso obligatorio que a menudo se pasa por alto. Sin esta configuración, no podrá consultar las tablas de Lente de almacenamiento de S3 mediante los servicios de análisis de AWS.

## Requisitos previos
<a name="storage-lens-s3-tables-querying-prerequisites"></a>

Antes de comenzar, asegúrese de que dispone de lo siguiente:
+ Configuración de lente de almacenamiento de S3 con la exportación de tablas de S3 habilitada. Para obtener más información, consulte  [Exportación de métricas de Lente de almacenamiento de S3 a tablas de S3](storage-lens-s3-tables-export.md) .
+ Acceso a Amazon Athena u otro servicio de análisis.
+ Esperó de 24 a 48 horas después de habilitar la exportación para que estuvieran disponibles los primeros datos.

## Información general de la integración
<a name="storage-lens-s3-tables-querying-integration-overview"></a>

Para obtener información detallada sobre la integración de las tablas de S3 con los servicios de análisis de AWS, incluidos los requisitos previos, la configuración de roles de IAM y los procedimientos paso a paso, consulte [Integración de tablas de Amazon S3 con los servicios de análisis de AWS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-integrating-aws.html). 

Tras habilitar la exportación de tablas de S3 y configurar la integración de análisis, puede consultar los datos de Lente de almacenamiento de S3 mediante servicios de análisis de AWS como Amazon Athena, Amazon Redshift y Amazon EMR. Esto permite realizar análisis personalizados, crear paneles y obtener información a partir de los datos de almacenamiento mediante SQL estándar.

## Consulta con Amazon Athena
<a name="storage-lens-s3-tables-querying-athena"></a>

Amazon Athena es un servicio de consultas interactivo sin servidor que facilita el análisis de datos con SQL estándar. Siga los pasos siguientes para consultar los datos de lente de almacenamiento de S3 en Athena.

**nota**  
En todos los ejemplos de consultas, sustituya `lens_my-config_exp` por el espacio de nombres de configuración de lente de almacenamiento actual. Para obtener más información acerca de la nomenclatura del espacio de nombres, consulte [Denominación de la tabla para la exportación de Lente de almacenamiento de S3 a tablas de S3](storage-lens-s3-tables-naming.md).

### Ejemplo: consulte a los principales consumidores de almacenamiento
<a name="storage-lens-s3-tables-querying-athena-top-consumers"></a>

La siguiente consulta identifica los 10 buckets principales por consumo de almacenamiento:

```
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
```

### Ejemplo: analice el crecimiento del almacenamiento a lo largo del tiempo
<a name="storage-lens-s3-tables-querying-athena-growth"></a>

La siguiente consulta analiza el crecimiento del almacenamiento de los últimos 30 días:

```
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;
```

### Ejemplo: identifique cargas multiparte incompletas
<a name="storage-lens-s3-tables-querying-athena-mpu"></a>

En la consulta siguiente, se encuentran buckets con cargas multiparte incompletas de más de 7 días:

```
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;
```

### Ejemplo: encuentre candidatos de datos inactivos
<a name="storage-lens-s3-tables-querying-athena-cold-data"></a>

La siguiente consulta identifica los prefijos que no han tenido actividad en los últimos 100 días y que se almacenan en los niveles de almacenamiento activo:

```
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;
```

### Ejemplo: analice los patrones de solicitudes
<a name="storage-lens-s3-tables-querying-athena-requests"></a>

La consulta siguiente, analiza los patrones de solicitud para comprender la frecuencia de acceso:

```
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;
```

## Consultas con Apache Spark en Amazon EMR
<a name="storage-lens-s3-tables-querying-emr"></a>

Amazon EMR proporciona un marco Hadoop administrado que facilita procesar grandes cantidades de datos mediante Apache Spark. Puede utilizar el conector de Iceberg para leer tablas de Lente de almacenamiento de S3 directamente.

### Lectura de las tablas de S3 con Spark
<a name="storage-lens-s3-tables-querying-emr-spark"></a>

Use el siguiente código de Python para leer los datos de lente de almacenamiento de S3 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)
```

## Prácticas recomendadas de optimización de costos
<a name="storage-lens-s3-tables-querying-optimization"></a>

Siga estas prácticas recomendadas para optimizar el rendimiento de las consultas y reducir los costos:
+  **Filtre por report\_time**: incluya siempre filtros de fecha para reducir la cantidad de datos analizados. Esto es especialmente importante para tablas con periodos de retención largos.

  ```
  WHERE report_time >= current_date - interval '7' day
  ```
+  **Utilice filtros record\_type**: especifique el nivel de agregación adecuado (ACCOUNT, BUCKET, PREFIX) para consultar solo los datos que necesita.

  ```
  WHERE record_type = 'BUCKET'
  ```
+  **Incluya cláusulas LIMIT**: utilice LIMIT en las consultas exploratorias para controlar el tamaño de los resultados y reducir los costos de las consultas.

  ```
  LIMIT 100
  ```
+  **Filtre registros vacíos**: utilice condiciones para excluir los registros vacíos o de valor cero.

  ```
  WHERE storage_bytes > 0
  ```
+  **Utilice los datos más recientes**: al analizar el estado actual, filtre por el report\_time más reciente para evitar analizar datos históricos.

  ```
  WHERE report_time = (SELECT MAX(report_time) FROM table_name)
  ```

### Ejemplo de patrón de consulta optimizado
<a name="storage-lens-s3-tables-querying-optimization-example"></a>

La consulta siguiente muestra las prácticas recomendadas de optimización:

```
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
```

## Solución de problemas
<a name="storage-lens-s3-tables-querying-troubleshooting"></a>

### La consulta no devuelve ningún resultado
<a name="storage-lens-s3-tables-querying-troubleshooting-no-results"></a>

 **Problema:** la consulta se completa correctamente pero no devuelve ningún resultado.

 **Solución:** 
+ Compruebe que los datos estén disponibles consultando el report\_time más reciente:

  ```
  SELECT MAX(report_time) AS latest_data
  FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."default_storage_metrics";
  ```
+ asegúrese de utilizar el nombre de espacio de nombres correcto. Use `SHOW TABLES IN `lens_my-config_exp`;` para mostrar las tablas disponibles.
+ Espere de 24 a 48 horas después de habilitar la exportación de tablas de S3 para que estén disponibles los primeros datos.

### Errores de acceso denegado
<a name="storage-lens-s3-tables-querying-troubleshooting-access"></a>

 **Problema:** al ejecutar consultas, aparecen errores de acceso denegado.

 **Solución:** compruebe que los permisos de AWS Lake Formation estén configurados correctamente. Para obtener más información, consulte [Integración de Tablas de Amazon S3 con servicios de análisis de AWS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-integrating-aws.html). 

## Siguientes pasos
<a name="storage-lens-s3-tables-querying-next-steps"></a>
+ Información sobre [Uso de asistentes de IA con tablas de lente de almacenamiento de S3](storage-lens-s3-tables-ai-tools.md)
+ Revisión de [Glosario de métricas de Amazon S3 Storage Lens](storage_lens_metrics_glossary.md) para definiciones de métricas
+ Exploración de [Casos de uso de métricas de Lente de almacenamiento de Amazon S3](storage-lens-use-cases.md) para obtener más ideas de análisis
+ Obtención de información sobre [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) para consultas sin servidor