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
**Wichtig**
Die Aktivierung der Analyseintegration im Tabellen-Bucket „aws-s3“ ist ein erforderlicher Schritt, der häufig übersehen wird. Ohne diese Konfiguration können Sie Ihre S3 Storage Lens-Tabellen nicht mithilfe AWS von Analysediensten abfragen.
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Eine S3-Storage-Lens-Konfiguration mit aktiviertem Export von S3-Tabellen. Weitere Informationen finden Sie unter [Exportieren von S3 Storage Lens-Metriken in S3-Tabellen](storage-lens-s3-tables-export.md).
+ Zugriff auf Amazon Athena oder einen anderen Analysedienst.
+ Nach der Aktivierung des Exports wurde 24-48 Stunden gewartet, bis die ersten Daten verfügbar waren.
## Ü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](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-integrating-aws.html).
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.
**Anmerkung**
Ersetzen Sie es in allen Abfragebeispielen `lens_my-config_exp` durch Ihren tatsächlichen Storage Lens-Konfigurationsnamespace. Weitere Informationen zur Namespace-Benennung finden Sie unter. [Benennung von Tabellen für den Export von S3 Storage Lens in S3-Tabellen](storage-lens-s3-tables-naming.md)
### 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:
+ Nach **report\_time filtern — Verwenden** Sie immer Datumsfilter, um die Menge der gescannten Daten zu reduzieren. Dies ist besonders wichtig für Tabellen mit langen Aufbewahrungszeiträumen.
```
WHERE report_time >= current_date - interval '7' day
```
+ **Verwenden Sie record\_type-Filter** — Geben Sie die entsprechende Aggregationsebene (ACCOUNT, BUCKET, PREFIX) an, um nur die Daten abzufragen, die Sie benötigen.
```
WHERE record_type = 'BUCKET'
```
+ **LIMIT-Klauseln einbeziehen** — Verwenden Sie LIMIT für explorative Abfragen, um die Ergebnisgröße zu kontrollieren und die Abfragekosten zu senken.
```
LIMIT 100
```
+ **Leere Datensätze filtern** — Verwenden Sie Bedingungen, um leere Datensätze oder Datensätze mit Nullwert auszuschließen.
```
WHERE storage_bytes > 0
```
+ Aktuelle **Daten verwenden — Filtern Sie bei der Analyse des aktuellen Status nach dem neuesten** report\_time, um zu vermeiden, dass historische Daten gescannt werden.
```
WHERE report_time = (SELECT MAX(report_time) FROM table_name)
```
### 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:**
+ Überprüfen Sie, ob Daten verfügbar sind, indem Sie die neueste Version von report\_time überprüfen:
```
SELECT MAX(report_time) AS latest_data
FROM "s3tablescatalog/aws-s3"."lens_my-config_exp"."default_storage_metrics";
```
+ Stellen Sie sicher, dass Sie den richtigen Namespace-Namen verwenden. Wird verwendet`SHOW TABLES IN `lens_my-config_exp`;`, um verfügbare Tabellen aufzulisten.
+ Warten Sie 24 bis 48 Stunden, nachdem Sie den Export von S3-Tabellen aktiviert haben, bis die ersten Daten verfügbar sind.
### 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.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-integrating-aws.html)
## Nächste Schritte
+ Weitere Informationen über [Verwendung von KI-Assistenten mit S3 Storage Lens-Tabellen](storage-lens-s3-tables-ai-tools.md)
+ Sehen Sie sich die [Amazon S3-Storage-Lens-Metrikglossar](storage_lens_metrics_glossary.md) Definitionen von Metriken an
+ Weitere Ideen [Anwendungsfälle für Metriken von Amazon S3 Storage Lens](storage-lens-use-cases.md) zur Analyse finden Sie hier
+ Erfahren Sie mehr über [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) für serverlose Abfragen