Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Abfragen von S3 Storage Lens-Daten mit Analysetools

Bevor Sie mit AWS Analysediensten wie Amazon Athena oder Amazon EMR in S3-Tabellen exportierte S3 Storage Lens-Daten abfragen können, müssen Sie die Analyseintegration für den AWS-verwalteten Tabellen-Bucket `aws-s3` aktivieren und Berechtigungen konfigurieren. AWS Lake Formation

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

Übersicht über die Integration

Ausführliche Informationen zur Integration von S3-Tabellen mit AWS Analyseservices, einschließlich Voraussetzungen, IAM-Rollenkonfiguration und step-by-step Verfahren, finden Sie unter Integration von Amazon S3-Tabellen mit AWS Analyseservices.

Nachdem Sie den Export von S3-Tabellen aktiviert und die Analyseintegration eingerichtet haben, können Sie Ihre S3 Storage Lens-Daten mithilfe von AWS Analysediensten wie Amazon Athena, Amazon Redshift und Amazon EMR abfragen. Auf diese Weise können Sie mithilfe von Standard-SQL benutzerdefinierte Analysen durchführen, Dashboards erstellen und Erkenntnisse aus Ihren Speicherdaten ableiten.

Abfragen mit Amazon Athena

Amazon Athena ist ein serverloser interaktiver Abfrageservice, der es einfach macht, Daten mit Standard-SQL zu analysieren. Gehen Sie wie folgt vor, um S3 Storage Lens-Daten in Athena abzufragen.

Beispiel: Fragen Sie die meisten Speicherverbraucher ab

Die folgende Abfrage identifiziert die 10 Buckets, die den Speicherverbrauch am häufigsten betreffen:

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

Beispiel: Analysieren Sie das Speicherwachstum im Laufe der Zeit

Die folgende Abfrage analysiert das Speicherwachstum in den letzten 30 Tagen:

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;

Beispiel: Identifizieren Sie unvollständige mehrteilige Uploads

Die folgende Abfrage findet Buckets mit unvollständigen mehrteiligen Uploads, die älter als 7 Tage sind:

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;

Beispiel: Finden Sie Kandidaten für kalte Daten

Die folgende Abfrage identifiziert Präfixe, die in den letzten 100 Tagen nicht aktiv waren und in heißen Speicherebenen gespeichert wurden:

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;

Beispiel: Analysieren Sie Anforderungsmuster

Die folgende Abfrage analysiert Anforderungsmuster, um die Zugriffshäufigkeit zu ermitteln:

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;

Abfragen mit Apache Spark auf Amazon EMR

Amazon EMR bietet ein verwaltetes Hadoop-Framework, das es einfach macht, riesige Datenmengen mit Apache Spark zu verarbeiten. Sie können den Iceberg-Connector verwenden, um S3 Storage Lens-Tabellen direkt zu lesen.

Lesen Sie S3-Tabellen mit Spark

Verwenden Sie den folgenden Python-Code, um S3 Storage Lens-Daten mit Spark zu lesen:

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)

Bewährte Methoden zur Abfrageoptimierung

Folgen Sie diesen bewährten Methoden, um die Abfrageleistung zu optimieren und die Kosten zu senken:

Beispiel für ein optimiertes Abfragemuster

Die folgende Abfrage zeigt bewährte Methoden für die Optimierung:

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

Fehlerbehebung

Die Abfrage gibt keine Ergebnisse zurück

Problem: Ihre Abfrage wurde erfolgreich abgeschlossen, liefert aber keine Ergebnisse.

Lösung:

Fehler aufgrund einer Zugriffsverweigerung

Problem: Beim Ausführen von Abfragen erhalten Sie die Fehlermeldung „Zugriff verweigert“.

Lösung: Stellen Sie sicher, dass die AWS Lake Formation Berechtigungen korrekt konfiguriert sind. Weitere Informationen finden Sie unter Integration von Amazon S3 S3-Tabellen mit AWS Analysediensten.

Nächste Schritte