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.
# Amazon-S3-Verbindungen
Sie können AWS Glue for Spark verwenden, um Dateien in Amazon S3 zu lesen und zu schreiben. AWS Glue for Spark unterstützt viele gängige Datenformate, die standardmäßig in Amazon S3 gespeichert sind, darunter CSV, Avro, JSON, Orc und Parquet. Weitere Informationen zu unterstützten Datenformaten finden Sie unter [Mögliche Formate für Eingaben und Ausgaben in AWS Glue für Spark](aws-glue-programming-etl-format.md). Jedes Datenformat unterstützt möglicherweise einen anderen Satz von AWS Glue-Funktionen. Informieren Sie sich auf der Seite für Ihr Datenformat über die Besonderheiten der Feature-Unterstützung. Darüber hinaus können Sie versionierte Dateien lesen und schreiben, die in den Data-Lake-Frameworks Hudi, Iceberg und Delta Lake gespeichert sind. Weitere Informationen zu Data Lake-Frameworks finden Sie unter [Verwendung von Data-Lake-Frameworks mit AWS Glue ETL-Jobs](aws-glue-programming-etl-datalake-native-frameworks.md).
Mit AWS Glue können Sie Ihre Amazon S3 S3-Objekte beim Schreiben in eine Ordnerstruktur partitionieren und sie dann partitionsweise abrufen, um die Leistung mithilfe einer einfachen Konfiguration zu verbessern. Sie können die Konfiguration auch so festlegen, dass kleine Dateien beim Transformieren Ihrer Daten gruppiert werden, um die Leistung zu verbessern. Sie können in Amazon S3 lesen, `bzip2` schreiben und `gzip` archivieren.
**Topics**
+ [Konfiguration von S3-Verbindungen](#aws-glue-programming-etl-connect-s3-configure)
+ [Referenz zur Amazon-S3-Verbindungsoption](#aws-glue-programming-etl-connect-s3)
+ [Veraltete Verbindungssyntaxen für Datenformate](#aws-glue-programming-etl-connect-legacy-format)
+ [Ausschließen von Amazon-S3-Speicherklassen](aws-glue-programming-etl-storage-classes.md)
+ [Verwalten von Partitionen für die ETL-Ausgabe in AWS Glue](aws-glue-programming-etl-partitions.md)
+ [Zusammenfassen von Eingabedateien in größeren Gruppen beim Lesen](grouping-input-files.md)
+ [Amazon-VPC-Endpunkte für Amazon S3](vpc-endpoints-s3.md)
## Konfiguration von S3-Verbindungen
Um in einem AWS Glue with Spark-Job eine Verbindung zu Amazon S3 herzustellen, benötigen Sie einige Voraussetzungen:
+ Der AWS Glue-Job muss über IAM-Berechtigungen für relevante Amazon S3 S3-Buckets verfügen.
In bestimmten Fällen müssen Sie zusätzliche Voraussetzungen konfigurieren:
+ Bei der Konfiguration des kontoübergreifenden Zugriffs sind entsprechende Zugriffskontrollen für den Amazon-S3-Bucket erforderlich.
+ Aus Sicherheitsgründen können Sie Ihre Amazon-S3-Anfragen über eine Amazon VPC weiterleiten. Dieser Ansatz kann zu Herausforderungen in Bezug auf Bandbreite und Verfügbarkeit führen. Weitere Informationen finden Sie unter [Amazon-VPC-Endpunkte für Amazon S3](vpc-endpoints-s3.md).
## Referenz zur Amazon-S3-Verbindungsoption
Bezeichnet eine Verbindung mit Amazon S3.
Da Amazon S3 Dateien und nicht Tabellen verwaltet, müssen Sie zusätzlich zur Angabe der in diesem Dokument bereitgestellten Verbindungseigenschaften auch zusätzliche Konfigurationen für Ihren Dateityp angeben. Sie geben diese Informationen über Datenformatoptionen an. Weitere Informationen zu den Formatoptionen finden Sie unter [Mögliche Formate für Eingaben und Ausgaben in AWS Glue für Spark](aws-glue-programming-etl-format.md). Sie können diese Informationen auch durch die Integration mit dem AWS Glue Data Catalog angeben.
Betrachten Sie als Beispiel für die Unterscheidung zwischen Verbindungsoptionen und Formatoptionen die Art und Weise, wie die [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options)-Methode `connection_type`, `connection_options`, `format` und `format_options` verwendet. In diesem Abschnitt werden speziell die für `connection_options` bereitgestellten Parameter erläutert.
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "s3"`:
+ `"paths"`: (Erforderlich) Eine Liste der Amazon-S3-Pfade, aus denen gelesen werden soll.
+ `"exclusions"`: (Optional) Eine Zeichenfolge, die eine JSON-Liste der auszuschließenden Glob-Muster im Unix-Stil enthält. Beispiel: `"[\"**.pdf\"]"` schließt alle PDF-Dateien aus. Weitere Informationen zur Glob-Syntax, die AWS Glue unterstützt, finden Sie unter [Include- und Exclude-Muster](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude).
+ `"compressionType"` oder "`compression`": (Optional) Gibt an, wie die Daten komprimiert werden. Verwenden von `"compressionType"` für Amazon-S3-Quellen und `"compression"` für Amazon-S3-Ziele. Dies ist in der Regel nicht notwendig, wenn die Daten eine Standard-Dateierweiterung haben. Mögliche Werte sind `"gzip"` und `"bzip2"`). Für bestimmte Formate werden möglicherweise zusätzliche Komprimierungsformate unterstützt. Einzelheiten zur Feature-Unterstützung finden Sie auf der Seite zum Datenformat.
+ `"groupFiles"`: (Optional) Die Gruppierung von Dateien ist standardmäßig aktiviert, wenn die Eingabe mehr als 50 000 Dateien enthält. Um die Gruppierung mit weniger als 50 000 Dateien zu aktivieren, setzen Sie diesen Parameter auf `"inPartition"`. Um die Gruppierung zu deaktivieren, wenn mehr als 50 000 Dateien vorhanden sind, setzen Sie diesen Parameter auf `"none"`.
+ `"groupSize"`: (Optional) Die Größe der Zielgruppe in Bytes. Der Standardwert wird anhand der Größe der Eingabedaten und der Größe des Clusters berechnet. Wenn es weniger als 50 000 Eingabedateien gibt, muss `"groupFiles"` auf `"inPartition"` gesetzt werden, damit dies wirksam wird.
+ `"recurse"`: (Optional) Wenn auf true gesetzt, werden Dateien in allen Unterverzeichnissen unter den angegebenen Pfaden rekursiv gelesen.
+ `"maxBand"`: (Optional, erweitert) – Diese Option steuert die Dauer in Millisekunden, nach der die `s3`-Auflistung wahrscheinlich konsistent ist. Dateien mit Änderungszeitstempeln, die innerhalb der letzten `maxBand` Millisekunden liegen, werden vor allem bei der Verwendung von `JobBookmarks` zur Berücksichtigung der letztendlichen Konsistenz von Amazon S3 verfolgt. Die meisten Benutzer müssen diese Option nicht festlegen. Der Standardwert ist 900 000 Millisekunden oder 15 Minuten
+ `"maxFilesInBand"`: (Optional, erweitert) – Diese Option gibt die maximale Anzahl von Dateien an, die aus den letzten `maxBand` Sekunden gespeichert werden sollen. Wird diese Anzahl überschritten, werden zusätzliche Dateien übersprungen und erst bei der nächsten Auftragsausführung verarbeitet. Die meisten Benutzer müssen diese Option nicht festlegen.
+ `"isFailFast"`: (Optional) Diese Option bestimmt, ob ein AWS Glue-ETL-Auftrag Reader-Parsing-Ausnahmen ausgibt. Wenn `true`, schlagen Aufträge schnell fehl, wenn vier Wiederholungen der Spark-Aufgabe die Daten nicht korrekt parsen.
+ `"catalogPartitionPredicate"`: (Optional) Wird zum Lesen verwendet. Der Inhalt einer SQL-`WHERE`-Klausel. Wird beim Lesen aus Data-Catalog-Tabellen mit einer sehr großen Anzahl von Partitionen verwendet. Ruft passende Partitionen aus Data-Catalog-Indizes ab. Wird mit `push_down_predicate`, einer Option der [create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog)-Methode (und anderen ähnlichen Methoden) verwendet. Weitere Informationen finden Sie unter [Serverseitige Filterung mit Katalogpartitionsprädikaten](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates).
+ `"partitionKeys"`: (Optional) Wird zum Schreiben verwendet. Ein Array von Zeichenketten mit Spaltenbezeichnungen. AWS Glue partitioniert Ihre Daten wie in dieser Konfiguration angegeben. Weitere Informationen finden Sie unter [Schreiben von Partitionen](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-writing).
+ `"excludeStorageClasses"`: (Optional) Wird zum Lesen verwendet. Ein Array von Zeichenketten, die Amazon S3 S3-Speicherklassen angeben. AWS Glue schließt Amazon S3 S3-Objekte basierend auf dieser Konfiguration aus. Weitere Informationen finden Sie unter [Ausschließen von Amazon-S3-Speicherklassen](aws-glue-programming-etl-storage-classes.md).
## Veraltete Verbindungssyntaxen für Datenformate
Auf bestimmte Datenformate kann mithilfe einer bestimmten Verbindungstyp-Syntax zugegriffen werden. Diese Syntax ist veraltet. Wir empfehlen Ihnen, Ihre Formate stattdessen mithilfe des `s3`-Verbindungstyps und der in [Mögliche Formate für Eingaben und Ausgaben in AWS Glue für Spark](aws-glue-programming-etl-format.md) bereitgestellten Formatoptionen anzugeben.
### "connectionType": "orc"
Bezeichnet eine Verbindung zu Dateien, die in Amazon S3 im Dateiformat [Apache Hive Optimized Row Columnar (ORC)](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC) gespeichert sind.
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "orc"`:
+ `paths`: (Erforderlich) Eine Liste der Amazon-S3-Pfade, aus denen gelesen werden soll.
+ *(Andere name/value Optionspaare)*: Alle zusätzlichen Optionen, einschließlich Formatierungsoptionen, werden direkt an SparkSQL übergeben. `DataSource`
### "connectionType": "parquet"
Bezeichnet eine Verbindung mit Dateien, die in Amazon S3 im Dateiformat [Apache Parquet](https://parquet.apache.org/docs/) gespeichert sind.
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "parquet"`:
+ `paths`: (Erforderlich) Eine Liste der Amazon-S3-Pfade, aus denen gelesen werden soll.
+ *(Andere name/value Optionspaare)*: Alle zusätzlichen Optionen, einschließlich Formatierungsoptionen, werden direkt an SparkSQL übergeben. `DataSource`
# Ausschließen von Amazon-S3-Speicherklassen
Wenn Sie AWS Glue-ETL-Aufträge ausführen, die Dateien oder Partitionen aus Amazon Simple Storage Service (Amazon S3) lesen, können Sie einige Amazon-S3-Speicherklassentypen ausschließen.
Die folgenden Speicherklassen sind in Amazon S3 verfügbar:
+ `STANDARD` – Für die universelle Speicherung häufig aufgerufener Daten.
+ `INTELLIGENT_TIERING` – Für Daten mit wechselnden oder unbekannten Zugriffsmustern.
+ `STANDARD_IA` und `ONEZONE_IA` – Für langlebige Daten, auf die weniger häufig zugegriffen wird.
+ `GLACIER`, `DEEP_ARCHIVE` und `REDUCED_REDUNDANCY` – Für die Langzeitarchivierung und digitale Archivierung.
Weitere Informationen finden Sie unter [Amazon S3 Storage Classes (Amazon-S3-Speicherklassen)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html) im *Amazon-S3-Entwicklerhandbuch*.
Die Beispiele in diesem Abschnitt zeigen, wie Sie die `GLACIER`- und `DEEP_ARCHIVE`-Speicherklassen ausschließen. Mit diesen Klassen können Sie Dateien auflisten, aber Sie können die Dateien nur lesen, wenn sie wiederhergestellt werden. (Weitere Informationen finden Sie unter [Restoring Archived Objects (Wiederherstellen archivierter Objekte)](https://docs.aws.amazon.com/AmazonS3/latest/dev/restoring-objects.html) im *Amazon-S3-Entwicklerhandbuch*.)
Durch die Verwendung von Speicherklassenausschlüssen können Sie sicherstellen, dass Ihre AWS Glue-Aufträge für Tabellen funktionieren, die über Partitionen in diesen Speicherklassenstufen verfügen. Ohne Ausnahmen schlagen Aufträge, die Daten aus diesen Stufen lesen, mit dem folgenden Fehler fehl: AmazonS3Exception: The operation is not valid for the object storage class.
Es gibt verschiedene Möglichkeiten, Amazon-S3-Speicherklassen in AWS Glue zu filtern.
**Topics**
+ [Ausschließen von Amazon-S3-Speicherklassen beim Erstellen eines Dynamic Frames](#aws-glue-programming-etl-storage-classes-dynamic-frame)
+ [Ausschließen von Amazon-S3-Speicherklassen in einer Data-Catalog-Tabelle](#aws-glue-programming-etl-storage-classes-table)
## Ausschließen von Amazon-S3-Speicherklassen beim Erstellen eines Dynamic Frames
Um Amazon S3-Speicherklassen beim Erstellen eines dynamischen Frames auszuschließen, verwenden Sie `excludeStorageClasses` in `additionalOptions`. AWS Glue verwendet automatisch eine eigene Amazon S3 `Lister`-Implementierung, um Dateien aufzulisten und auszuschließen, die den angegebenen Speicherklassen entsprechen.
Die folgenden Python- und Scala-Beispiele zeigen, wie Sie die Speicherklassen `GLACIER` und `DEEP_ARCHIVE` beim Erstellen eines Dynamic Frames ausschließen.
Python-Beispiel:
```
glueContext.create_dynamic_frame.from_catalog(
database = "my_database",
tableName = "my_table_name",
redshift_tmp_dir = "",
transformation_ctx = "my_transformation_context",
additional_options = {
"excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
}
)
```
Scala-Beispiel:
```
val* *df = glueContext.getCatalogSource(
nameSpace, tableName, "", "my_transformation_context",
additionalOptions = JsonOptions(
Map("excludeStorageClasses" -> List("GLACIER", "DEEP_ARCHIVE"))
)
).getDynamicFrame()
```
## Ausschließen von Amazon-S3-Speicherklassen in einer Data-Catalog-Tabelle
Sie können Speicherklassenausschlüsse, die von einem AWS Glue ETL-Job verwendet werden sollen, als Tabellenparameter im AWS Glue-Datenkatalog angeben. Sie können diesen Parameter mithilfe von AWS Command Line Interface (AWS CLI) oder programmgesteuert mithilfe der API in den `CreateTable` Vorgang einbeziehen. Weitere Informationen finden Sie unter [Tabellenstruktur](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-Table) und. [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)
Sie können auch ausgeschlossene Speicherklassen in der AWS Glue-Konsole angeben.
**Ausschließen von Amazon-S3-Speicherklassen (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Wählen Sie im Navigationsbereich auf der linken Seite **Tabellen** aus.
1. Wählen Sie den Tabellennamen in der Liste aus und klicken Sie dann auf **Edit table (Tabelle bearbeiten)**.
1. Fügen Sie unter **Table properties (Tabelleneigenschaften)** **excludeStorageClasses** als Schlüssel und **[\$1"GLACIER\$1",\$1"DEEP\$1ARCHIVE\$1"]** als Wert hinzu.
1. Wählen Sie **Anwenden** aus.
# Verwalten von Partitionen für die ETL-Ausgabe in AWS Glue
Die Partitionierung ist eine wichtige Methode zum Organisieren von Datasets, sodass diese effizient abgefragt werden können. Sie ordnet Daten basierend auf den individuellen Werten einer oder mehrerer Spalten in eine hierarchische Verzeichnisstruktur.
Beispiel: Sie können Ihre Anwendungsprotokolle in Amazon Simple Storage Service (Amazon S3) nach Datum, aufgeschlüsselt nach Jahr, Monat und Tag, partitionieren. Dateien, die der Datenmenge eines einzelnen Tages entsprechen, werden dann unter einem Präfix wie `s3://my_bucket/logs/year=2018/month=01/day=23/` geordnet. Systeme wie Amazon Athena, Amazon Redshift Spectrum und nun auch AWS Glue können diese Partitionen zum Filtern von Daten nach Partitionswert verwenden, ohne die zugrunde liegenden Daten aus Amazon S3 lesen zu müssen.
Crawler leiten nicht nur Dateitypen und Schemas ab, sie identifizieren auch automatisch die Partitionsstruktur Ihres Datensatzes, wenn sie den AWS Glue-Datenkatalog füllen. Die resultierenden Partitionsspalten stehen für das Abfragen von ETL-Aufträgen in AWS Glue oder das Abfragen von Engines wie Amazon Athena zur Verfügung.
Nachdem Sie eine Tabelle durchsucht haben, können Sie die Partitionen anzeigen, die vom Crawler erstellt wurden. Wählen Sie im linken Navigationsbereich der AWS Glue-Konsole **Tables (Tabellen)** aus. Wählen Sie die vom Crawler erstellte Tabelle und dann **View Partitions (Partionen anzeigen)** aus.
Für Apache Hive-ähnliche partitionierte Pfade im `key=val`-Stil füllen Crawler den Spaltennamen automatisch mit dem Schlüsselnamen. Andernfalls werden Standardnamen wie z. B. `partition_0`, `partition_1` usw. verwendet. Sie können die Standardnamen in der Konsole ändern. Navigieren Sie dazu zur Tabelle. Überprüfen Sie, ob Indizes auf der Registerkarte **Indizes** vorhanden sind. Wenn das der Fall ist, müssen Sie sie löschen, um fortzufahren (Sie können sie anschließend mit den neuen Spaltennamen neu erstellen). Wählen Sie dann **Schema bearbeiten** und ändern Sie dort die Namen der Partitionsspalten.
In Ihren ETL-Skripts können Sie dann die Partitionsspalten filtern. Da die Partitionsinformationen im Data Catalog gespeichert sind, verwenden Sie die `from_catalog`-API-Aufrufe, um die Partitionsspalten in `DynamicFrame` zu erfassen. Verwenden Sie z. B. `create_dynamic_frame.from_catalog` statt `create_dynamic_frame.from_options`.
Partitionierung ist eine Optimierungsmethode, die zu einer geringeren Menge an gescannten Daten führt. 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.
## Vorabfilterung mit Pushdown-Prädikaten
In vielen Fällen können Sie ein Pushdown-Prädikat zum Filtern von Partitionen verwenden, ohne alle Dateien Ihres Datasets auflisten und lesen zu müssen. Anstatt den gesamten Datensatz zu lesen und dann in einem zu filtern DynamicFrame, können Sie den Filter direkt auf die Metadaten der Partition im Datenkatalog anwenden. Dann listen Sie nur auf und lesen in eine ein, was Sie tatsächlich benötigen DynamicFrame.
In Python können Sie beispielsweise Folgendes schreiben:
```
glue_context.create_dynamic_frame.from_catalog(
database = "my_S3_data_set",
table_name = "catalog_data_table",
push_down_predicate = my_partition_predicate)
```
Dadurch wird eine erstellt DynamicFrame , die nur die Partitionen im Datenkatalog lädt, die dem Prädikatausdruck entsprechen. Je nachdem, wie klein eine Teilmenge der Daten ist, die Sie laden, kann dies sehr viel Verarbeitungszeit sparen.
Der Prädikatausdruck kann ein beliebiger boolescher Ausdruck sein, der von Spark SQL unterstützt wird. Alles, was Sie in eine `WHERE`-Klausel einer Spark SQL-Abfrage aufnehmen können, wird unterstützt. Beispiel: Mit dem Prädikatausdruck `pushDownPredicate = "(year=='2017' and month=='04')"` werden nur die Partitionen in den Data Catalog geladen, die sowohl `year` gleich 2017 und `month` gleich 04 ist. Weitere Informationen finden Sie in der [Apache Spark SQL-Dokumentation](https://spark.apache.org/docs/2.1.1/sql-programming-guide.html) und insbesondere in der [Scala SQL-Funktionsreferenz](https://spark.apache.org/docs/2.1.1/api/scala/index.html#org.apache.spark.sql.functions$).
## Serverseitige Filterung mit Katalogpartitionsprädikaten
Die Option `push_down_predicate` wird angewendet, nachdem alle Partitionen aus dem Katalog aufgelistet wurden und bevor Dateien von Amazon S3 für diese Partitionen angeboten werden. Wenn Sie viele Partitionen für eine Tabelle haben, kann die Liste der Katalogpartitionen immer noch zusätzlichen Zeitaufwand verursachen. Um diesen Mehraufwand zu beheben, können Sie serverseitiges Partitionsbereinigen mit der `catalogPartitionPredicate` Option verwenden, die [Partitionsindizes](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) im AWS Glue-Datenkatalog verwendet. Dies macht die Partitionsfilterung viel schneller, wenn Millionen von Partitionen in einer Tabelle vorhanden sind. Sie können sowohl `push_down_predicate` und `catalogPartitionPredicate` in `additional_options` zusammen verwenden, wenn Ihr `catalogPartitionPredicate` eine Prädikatsyntax erfordert, die noch nicht von den Katalogpartition-Indizes unterstützt wird.
Python:
```
dynamic_frame = glueContext.create_dynamic_frame.from_catalog(
database=dbname,
table_name=tablename,
transformation_ctx="datasource0",
push_down_predicate="day>=10 and customer_id like '10%'",
additional_options={"catalogPartitionPredicate":"year='2021' and month='06'"}
)
```
Scala:
```
val dynamicFrame = glueContext.getCatalogSource(
database = dbname,
tableName = tablename,
transformationContext = "datasource0",
pushDownPredicate="day>=10 and customer_id like '10%'",
additionalOptions = JsonOptions("""{
"catalogPartitionPredicate": "year='2021' and month='06'"}""")
).getDynamicFrame()
```
**Anmerkung**
`push_down_predicate` und `catalogPartitionPredicate` verwenden verschiedene Syntaxen. Erstere verwendet die Spark-SQL-Standardsyntax und letztere verwendet den JSQL-Parser.
## Schreiben von Partitionen
Standardmäßig DynamicFrame ist a beim Schreiben nicht partitioniert. Alle Ausgabedateien werden auf der obersten Ebene des angegebenen Ausgabepfads geschrieben. Bis vor Kurzem bestand die einzige Möglichkeit, eine DynamicFrame in Partitionen zu schreiben, darin, sie DataFrame vor dem Schreiben in eine Spark-SQL zu konvertieren.
Unterstützt DynamicFrames jetzt jedoch die native Partitionierung mit einer Tastenfolge, indem Sie die `partitionKeys` Option verwenden, wenn Sie eine Senke erstellen. Der folgende Python-Code schreibt beispielsweise in Amazon S3 einen Datensatz im Parquet-Format in Verzeichnisse, die nach dem Type-Feld partitioniert sind. Von dort aus können Sie diese Partitionen mit anderen Systemen wie Amazon Athena verarbeiten.
```
glue_context.write_dynamic_frame.from_options(
frame = projectedEvents,
connection_type = "s3",
connection_options = {"path": "$outpath", "partitionKeys": ["type"]},
format = "parquet")
```
# Zusammenfassen von Eingabedateien in größeren Gruppen beim Lesen
Sie können die Eigenschaften Ihrer Tabellen festlegen, damit ein AWS Glue-ETL-Auftrag Dateien gruppieren kann, wenn sie aus einem Amazon-S3-Datenspeicher gelesen werden. Diese Eigenschaften ermöglichen den einzelnen ETL-Aufträgen eine Gruppe von Eingabedateien in eine einzelne In-Memory-Partition zu lesen. Dies ist besonders nützlich, wenn es eine große Anzahl kleiner Dateien in Ihrem Amazon-S3-Datenspeicher gibt. Wenn Sie bestimmte Eigenschaften festlegen, weisen Sie AWS Glue an, Dateien innerhalb einer Amazon-S3-Datenpartition zu gruppieren und die Größe der zu lesenden Gruppen zu bestimmen. Sie können diese Optionen auch festlegen, wenn Sie mit der `create_dynamic_frame.from_options`-Methode Daten aus dem Amazon-S3-Datenspeicher lesen.
Zum Aktivieren von Gruppierungsdateien für eine Tabelle legen Sie Schlüssel-Wert-Paare im Parameterfeld Ihrer Tabellenstruktur fest. Verwenden Sie eine JSON-Notation, um einen Wert für das Parameterfeld Ihrer Tabelle festzulegen. Weitere Informationen zum Bearbeiten der Eigenschaften einer Tabelle finden Sie unter [Anzeigen und Verwalten von Tabellendetails](tables-described.md#console-tables-details).
Sie können mit dieser Methode das Gruppieren von Tabellen im Data Catalog bei Amazon-S3-Datenspeichern aktivieren.
**groupFiles**
Setzen Sie **groupFiles** auf `inPartition`, damit die Gruppierung von Dateien innerhalb einer Amazon-S3-Datenpartition ermöglicht wird. Bei mehr als 50 000 Eingabedateien aktiviert AWS Glue automatisch die Gruppierung.
```
'groupFiles': 'inPartition'
```
**groupSize**
Legen Sie **groupSize** auf die Zielgröße von Gruppen in Bytes fest. Die **groupSize**-Eigenschaft ist optional. Ist sie nicht bereitgestellt, berechnet AWS Glue eine Größe für die Verwendung aller CPU-Kerne im Cluster und reduziert gleichzeitig die Gesamtzahl an ETL-Aufträgen und In-Memory-Partitionen.
Im Folgenden wird beispielsweise die Gruppengröße auf 1 MB festgelegt.
```
'groupSize': '1048576'
```
Beachten Sie, dass `groupsize` mit dem Ergebnis einer Berechnung eingestellt werden sollte. Beispiel: 1024 \$1 1024 = 1048576.
**recurse**
Legen Sie **recurse (rekursiv)** auf `True` fest, um Dateien in allen Unterverzeichnissen zu lesen, wenn `paths` als ein Array von Pfaden angegeben wird. Sie müssen **rekursiv** nicht festlegen, wenn es sich bei `paths` um ein Array von Objektschlüsseln in Amazon S3 handelt, oder das Eingabeformat parquet/orc ist, wie im folgenden Beispiel.
```
'recurse':True
```
Wenn Sie direkt aus Amazon S3 mit der `create_dynamic_frame.from_options`-Methode lesen, fügen Sie diese Verbindungsoptionen hinzu. Im Folgenden wird beispielsweise versucht, Dateien in Gruppen mit einer Größe von 1 MB zusammenzufassen.
```
df = glueContext.create_dynamic_frame.from_options("s3", {'paths': ["s3://s3path/"], 'recurse':True, 'groupFiles': 'inPartition', 'groupSize': '1048576'}, format="json")
```
**Anmerkung**
`groupFiles`wird für die DynamicFrames Erstellung aus den folgenden Datenformaten unterstützt: csv, ion, GrokLog, json und xml. Diese Option wird für Avro, Parquet und Orc nicht unterstützt.
# Amazon-VPC-Endpunkte für Amazon S3
Aus Sicherheitsgründen führen viele AWS Kunden ihre Anwendungen in einer Amazon Virtual Private Cloud Cloud-Umgebung (Amazon VPC) aus. Mit Amazon VPC können Sie EC2 Amazon-Instances in einer virtuellen privaten Cloud starten, die logisch von anderen Netzwerken — einschließlich dem öffentlichen Internet — isoliert ist. Mit einer Amazon VPC können Sie den zugehörigen IP-Adressbereich, die Subnetze, Routing-Tabellen, Netzwerk-Gateways und Sicherheitseinstellungen steuern.
**Anmerkung**
Wenn Sie Ihr AWS Konto nach dem 04.12.2013 erstellt haben, haben Sie in jeder Region bereits eine Standard-VPC. AWS Sie können sofort beginnen, Ihre Standard-VPC zu verwenden, eine zusätzliche Konfiguration ist nicht erforderlich.
Weitere Informationen finden Sie unter [Ihre Standard-VPC und -Subnetze](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) im Amazon-VPC-Benutzerhandbuch.
Viele Kunden haben legitime Bedenken hinsichtlich Datenschutz und Sicherheit, was das Senden und Empfangen von Daten über das öffentliche Internet angeht. Kunden können dieses Problem durch die Verwendung eines Virtual Private Network (VPN) lösen, um sämtlichen Amazon-S3-Netzwerkdatenverkehr über die eigene Unternehmensnetzwerkinfrastruktur zu leiten. Dieser Ansatz kann jedoch zu Herausforderungen hinsichtlich Bandbreite und Verfügbarkeit führen.
VPC-Endpunkte für Amazon S3 können diese Herausforderungen bewältigen helfen. Ein VPC-Endpunkt für Amazon S3 ermöglicht AWS Glue die Verwendung privater IP-Adressen für den Zugriff auf Amazon S3, sodass sie nicht im öffentlichen Internet sichtbar sind. AWS Glue benötigt keine öffentlichen IP-Adressen, und Sie benötigen kein Internet-Gateway, kein NAT-Gerät oder ein Virtual Private Gateway in Ihrem VPC. Sie steuern den Zugriff auf Amazon S3 mittels Endpunktrichtlinien. Der Verkehr zwischen Ihrer VPC und dem AWS Service verlässt das Amazon-Netzwerk nicht.
Wenn Sie einen VPC-Endpunkt für Amazon S3 erstellen, werden alle Anfragen für einen Amazon-S3-Endpunkt in der Region (z. B. *s3.us-west-2.amazonaws.com*) an einen privaten Amazon-S3-Endpunkt innerhalb des Amazon-Netzwerks geleitet. Sie müssen Ihre Anwendungen, die auf EC2 Amazon-Instances in Ihrer VPC ausgeführt werden, nicht ändern — der Endpunktname bleibt derselbe, aber die Route zu Amazon S3 bleibt vollständig innerhalb des Amazon-Netzwerks und greift nicht auf das öffentliche Internet zu.
Weitere Informationen zu VPC-Endpunkten finden Sie unter [VPC-Endpunkte](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) im Amazon-VPC-Benutzerhandbuch.
Das folgende Diagramm zeigt, wie AWS Glue einen VPC-Endpunkt verwenden kann, um auf Amazon S3 zuzugreifen.
![\[Netzwerk-Datenverkehrsfluss zeigt VPC-Verbindung mit Amazon S3.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/PopulateCatalog-vpc-endpoint.png)
**So richten Sie den Zugriff für Amazon S3 ein**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im linken Navigationsbereich die Option **Endpoints** (Endpunkte) aus.
1. Wählen Sie **Create Endpoint (Endpunkt erstellen)** aus und befolgen Sie die Schritte zum Erstellen eines Amazon-S3-VPC-Endpunkts vom Typ Gateway.