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.
# Optimierung von Lesevorgängen mit Pushdown in AWS Glue ETL
Pushdown ist eine Optimierungstechnik, die die Logik zum Abrufen von Daten näher an die Quelle Ihrer Daten verschiebt. Die Quelle könnte eine Datenbank oder ein Dateisystem wie Amazon S3 sein. Wenn Sie bestimmte Operationen direkt an der Quelle ausführen, können Sie Zeit und Rechenleistung sparen, indem Sie nicht alle Daten über das Netzwerk an die von AWS Glue verwaltete Spark-Engine übertragen.
Anders ausgedrückt: Der Pushdown verringert die Menge an gescannten Daten. Weitere Informationen darüber, wie Sie feststellen können, wann diese Technik geeignet ist, finden Sie unter [Reduce the amount of data scan](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/reduce-data-scan.html) im Leitfaden *Best Practices for Performance Tuning AWS Glue for Apache Spark Jobs* auf AWS Prescriptive Guidance.
## Prädikat-Pushdown für auf Amazon S3 gespeicherte Dateien
Wenn Sie mit Dateien auf Amazon S3 arbeiten, die nach Präfixen organisiert wurden, können Sie Ihre Amazon-S3-Zielpfade filtern, indem Sie ein Pushdown-Prädikat definieren. Anstatt den vollständigen Datensatz zu lesen und Filter innerhalb eines `DynamicFrame` anzuwenden, können Sie den Filter direkt auf die im AWS Glue Data Catalog gespeicherten Partitionsmetadaten anwenden. Mit diesem Ansatz können Sie selektiv nur die erforderlichen Daten auflisten und lesen. Weitere Informationen zu diesem Prozess, einschließlich des Schreibens in einen Bucket nach Partitionen, finden Sie unter [Verwalten von Partitionen für die ETL-Ausgabe in AWS Glue](aws-glue-programming-etl-partitions.md).
Mithilfe des `push_down_predicate`-Parameters erreichen Sie einen Prädikat-Pushdown in Amazon S3. Betrachten Sie einen Bucket in Amazon S3, den Sie nach Jahr, Monat und Tag partitioniert haben. Wenn Sie Kundendaten für Juni 2022 abrufen möchten, können Sie AWS Glue anweisen, nur relevante Amazon S3 S3-Pfade zu lesen. Das `push_down_predicate` ist in diesem Fall `year='2022' and month='06'`. Zusammengenommen kann der Lesevorgang wie folgt durchgeführt werden:
------
#### [ Python ]
```
customer_records = glueContext.create_dynamic_frame.from_catalog(
database = "customer_db",
table_name = "customer_tbl",
push_down_predicate = "year='2022' and month='06'"
)
```
------
#### [ Scala ]
```
val customer_records = glueContext.getCatalogSource(
database="customer_db",
tableName="customer_tbl",
pushDownPredicate="year='2022' and month='06'"
).getDynamicFrame()
```
------
Im vorherigen Szenario ruft `push_down_predicate` eine Liste aller Partitionen aus dem AWS Glue Data Catalog ab und filtert sie, bevor die zugrunde liegenden Amazon-S3-Dateien gelesen werden. Obwohl dies in den meisten Fällen hilfreich ist, kann das Auflisten von Partitionen bei der Arbeit mit Datensätzen mit Millionen von Partitionen zeitaufwändig sein. Um dieses Problem zu beheben, kann die serverseitige Bereinigung von Partitionen zur Verbesserung der Leistung eingesetzt werden. Dazu wird ein **Partitionsindex** für Ihre Daten im AWS Glue-Datenkatalog erstellt. Weitere Informationen zu Partitionsindizes finden Sie unter [Erstellen von Partitionsindizes](partition-indexes.md). Anschließend können Sie die `catalogPartitionPredicate`-Option verwenden, um auf den Index zu verweisen. Ein Beispiel zum Abrufen von Partitionen mit `catalogPartitionPredicate` finden Sie unter [Serverseitige Filterung mit Katalogpartitionsprädikaten](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates).
## Pushdown beim Arbeiten mit JDBC-Quellen
Der im verwendete AWS Glue-JDBC-Reader `GlueContext` unterstützt Pushdown für unterstützte Datenbanken, indem er benutzerdefinierte SQL-Abfragen bereitstellt, die direkt auf der Quelle ausgeführt werden können. Dies kann durch Einstellen des `sampleQuery`-Parameters erreicht werden. Ihre Beispielabfrage kann angeben, welche Spalten ausgewählt werden sollen, und ein Pushdown-Prädikat bereitstellen, um die an die Spark-Engine übertragenen Daten zu begrenzen.
Standardmäßig werden Beispielabfragen auf einem einzelnen Knoten ausgeführt, was bei der Verarbeitung großer Datenmengen zu Auftragsfehlern führen kann. Um dieses Feature zur Abfrage von Daten in großem Umfang zu verwenden, sollten Sie die Abfragepartitionierung konfigurieren, indem Sie `enablePartitioningForSampleQuery` auf wahr festlegen. Dadurch wird die Abfrage auf mehrere Knoten über einen von Ihnen gewählten Schlüssel verteilt. Für die Abfragepartitionierung sind außerdem einige weitere notwendige Konfigurationsparameter erforderlich. Weitere Informationen zur Abfragepartitionierung finden Sie unter [Parallel aus JDBC-Tabellen lesen](run-jdbc-parallel-read-job.md).
Bei der Einstellung `enablePartitioningForSampleQuery` kombiniert AWS Glue bei der Abfrage Ihrer Datenbank Ihr Pushdown-Prädikat mit einem Partitionierungsprädikat. Sie `sampleQuery` müssen mit einem `AND` für AWS Glue enden, um Partitionierungsbedingungen anzuhängen. (Wenn Sie kein Pushdown-Prädikat angeben, muss `sampleQuery` mit einem `WHERE` enden). Unten sehen Sie ein Beispiel, in dem wir ein Prädikat nach unten verschieben, um nur Zeilen abzurufen, deren `id` größer ist als 1000. Dieser `sampleQuery` gibt nur die Namens- und Standortspalten für Zeilen zurück, in denen `id` größer als der angegebene Wert ist:
------
#### [ Python ]
```
sample_query = "select name, location from customer_tbl WHERE id>=1000 AND"
customer_records = glueContext.create_dynamic_frame.from_catalog(
database="customer_db",
table_name="customer_tbl",
sample_query = "select name, location from customer_tbl WHERE id>=1000 AND",
additional_options = {
"hashpartitions": 36 ,
"hashfield":"id",
"enablePartitioningForSampleQuery":True,
"sampleQuery":sample_query
}
)
```
------
#### [ Scala ]
```
val additionalOptions = Map(
"hashpartitions" -> "36",
"hashfield" -> "id",
"enablePartitioningForSampleQuery" -> "true",
"sampleQuery" -> "select name, location from customer_tbl WHERE id >= 1000 AND"
)
val customer_records = glueContext.getCatalogSource(
database="customer_db",
tableName="customer_tbl").getDynamicFrame()
```
------
**Anmerkung**
Wenn `customer_tbl` in Ihrem Datenkatalog und dem zugrunde liegenden Datenspeicher einen anderen Namen hat, müssen Sie den Namen der zugrunde liegenden Tabelle in „sample\$1query“ angeben, da die Abfrage an den zugrunde liegenden Datenspeicher übergeben wird.
Sie können auch JDBC-Tabellen abfragen, ohne sie in den AWS Glue-Datenkatalog zu integrieren. Anstatt Benutzername und Passwort als Parameter für die Methode anzugeben, können Sie Anmeldeinformationen einer bereits vorhandenen Verbindung wiederverwenden, indem Sie `useConnectionProperties` und `connectionName` angeben. In diesem Beispiel rufen wir Anmeldeinformationen von einer Verbindung mit dem Namen `my_postgre_connection` ab.
------
#### [ Python ]
```
connection_options_dict = {
"useConnectionProperties": True,
"connectionName": "my_postgre_connection",
"dbtable":"customer_tbl",
"sampleQuery":"select name, location from customer_tbl WHERE id>=1000 AND",
"enablePartitioningForSampleQuery":True,
"hashfield":"id",
"hashpartitions":36
}
customer_records = glueContext.create_dynamic_frame.from_options(
connection_type="postgresql",
connection_options=connection_options_dict
)
```
------
#### [ Scala ]
```
val connectionOptionsJson = """
{
"useConnectionProperties": true,
"connectionName": "my_postgre_connection",
"dbtable": "customer_tbl",
"sampleQuery": "select name, location from customer_tbl WHERE id>=1000 AND",
"enablePartitioningForSampleQuery" : true,
"hashfield" : "id",
"hashpartitions" : 36
}
"""
val connectionOptions = new JsonOptions(connectionOptionsJson)
val dyf = glueContext.getSource("postgresql", connectionOptions).getDynamicFrame()
```
------
## Hinweise und Einschränkungen für Pushdown in AWS Glue
Das Konzept von Pushdown ist anwendbar, wenn aus Quellen gelesen wird, die nicht gestreamt werden. AWS Glue unterstützt eine Vielzahl von Quellen — die Fähigkeit zum Drücken hängt von der Quelle und dem Anschluss ab.
+ Beim Herstellen einer Verbindung mit Snowflake können Sie die Option `query` verwenden. Ähnliche Funktionen gibt es im Redshift-Konnektor in AWS Glue 4.0 und späteren Versionen. Weitere Informationen zum Lesen aus Snowflake mit `query` finden Sie unter [Lesen aus Snowflake-Tabellen](aws-glue-programming-etl-connect-snowflake-home.md#aws-glue-programming-etl-connect-snowflake-read).
+ Der DynamoDB-ETL-Reader unterstützt keine Filter oder Pushdown-Prädikate. MongoDB und DocumentDB unterstützen diese Art von Funktionalität ebenfalls nicht.
+ Beim Lesen von in Amazon S3 gespeicherten Daten in offenen Tabellenformaten reicht die Partitionierungsmethode für Dateien in Amazon S3 nicht mehr aus. Informationen zum Lesen und Schreiben von Partitionen mithilfe offener Tabellenformate finden Sie in der Dokumentation zum Format.
+ DynamicFrame Methoden führen keinen Amazon S3 S3-Projektions-Pushdown durch. Alle Spalten werden aus Dateien gelesen, die den Prädikatfilter bestehen.
+ Bei der Arbeit mit `custom.jdbc` Anschlüssen in AWS Glue hängt die Fähigkeit zum Drücken von Druck von der Quelle und dem Anschluss ab. Bitte überprüfen Sie die entsprechende Connector-Dokumentation, um zu überprüfen, ob und wie Pushdown in AWS Glue unterstützt wird.