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. # Mögliche Formate für Eingaben und Ausgaben in AWS Glue für Spark Diese Seiten bieten Informationen zur Feature-Unterstützung und Konfigurationsparameter für Datenformate, die von AWS Glue für Spark unterstützt werden. Im Folgenden finden Sie eine Beschreibung der Verwendung und Anwendbarkeit dieser Informationen. ## Funktionsunterstützung für alle Datenformate in AWS Glue Jedes Datenformat kann unterschiedliche AWS Glue-Funktionen unterstützen. Die folgenden allgemeinen Features werden je nach Formattyp möglicherweise nicht unterstützt. Informieren Sie sich in der Dokumentation für Ihr Datenformat, um zu verstehen, wie Sie unsere Features zur Erfüllung Ihrer Anforderungen nutzen können. | | | | --- |--- | | Lesen | AWS Glue kann dieses Datenformat ohne zusätzliche Ressourcen wie Konnektoren erkennen und interpretieren. | | Schreiben | AWS Glue kann Daten in diesem Format ohne zusätzliche Ressourcen schreiben. Sie können Bibliotheken von Drittanbietern in Ihren Job einbeziehen und Standardfunktionen von Apache Spark verwenden, um Daten wie in anderen Spark-Umgebungen zu schreiben. Weitere Informationen einschließlich Bibliotheken finden Sie unter [Python-Bibliotheken mit AWS Glue verwenden](aws-glue-programming-python-libraries.md). | | Streaming gelesen | AWS Glue kann dieses Datenformat aus einem Apache Kafka-, Amazon Managed Streaming for Apache Kafka- oder Amazon Kinesis Kinesis-Nachrichtenstream erkennen und interpretieren. Wir erwarten, dass Streams Daten in einem konsistenten Format präsentieren, sodass sie als DataFrames eingelesen werden. | | Gruppieren von kleinen Dateien | AWS Glue kann Dateien gruppieren, um Batch-Arbeit zu erstellen, die bei der Durchführung von AWS Glue-Transformationen an jeden Knoten gesendet wird. Dies kann die Leistung für Workloads mit großen Mengen kleiner Dateien erheblich verbessern. Weitere Informationen finden Sie unter [Zusammenfassen von Eingabedateien in größeren Gruppen beim Lesen](grouping-input-files.md). | | Auftrags-Lesezeichen | AWS Glue kann mithilfe von Job-Lesezeichen den Fortschritt von Transformationen verfolgen, die dieselbe Arbeit an demselben Datensatz über Jobläufe hinweg ausführen. Dies kann die Leistung für Workloads mit Datensätzen verbessern, bei denen seit der letzten Auftragsausführung nur an neuen Daten gearbeitet werden muss. Weitere Informationen finden Sie unter [Verfolgen von verarbeiteten Daten mit Auftragslesezeichen](monitor-continuations.md). | ## Parameter, die für die Interaktion mit Datenformaten in AWS Glue verwendet werden Bestimmte AWS Glue-Verbindungstypen unterstützen mehrere `format` Typen, sodass Sie Informationen über Ihr Datenformat mit einem `format_options` Objekt angeben müssen, wenn Sie Methoden wie verwenden`GlueContext.write_dynamic_frame.from_options`. + `s3`— Weitere Informationen finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Sie können auch die Dokumentation für die Methoden anzeigen, die diesen Verbindungstyp unterstützt: [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) und [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options) in Python sowie die entsprechende Scala-Methoden [def-Format getSourceWith](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat) und [def-Format getSinkWith](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). + `kinesis`— Weitere Informationen finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[Kinesis-Verbindungsparameter](aws-glue-programming-etl-connect-kinesis-home.md#aws-glue-programming-etl-connect-kinesis). Sie können auch die Dokumentation für die Methode anzeigen, die diesen Verbindungstyp unterstützt: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) und die entsprechende Scala-Methode [def createDataFrame FromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions). + `kafka`— Weitere Informationen finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[Kafka-Verbindungsparameter](aws-glue-programming-etl-connect-kafka-home.md#aws-glue-programming-etl-connect-kafka). Sie können auch die Dokumentation für die Methode anzeigen, die diesen Verbindungstyp unterstützt: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) und die entsprechende Scala-Methode [def createDataFrame FromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions). Einige Verbindungstypen erfordern `format_options` nicht. Im Verlauf der normalen Verwendung ruft eine JDBC-Verbindung zu einer relationalen Datenbank zum Beispiel Daten in einem konsistenten, tabellarischen Datenformat ab. Daher wäre für das Lesen von einer JDBC-Verbindung `format_options` nicht erforderlich. Für einige Methoden zum Lesen und Schreiben von Daten in Glue ist `format_options` nicht erforderlich. Zum Beispiel `GlueContext.create_dynamic_frame.from_catalog` mit AWS Glue-Crawlern. Crawler bestimmen die Form Ihrer Daten. Wenn Sie Crawler verwenden, untersucht ein AWS Glue-Klassifikator Ihre Daten, um kluge Entscheidungen darüber zu treffen, wie Ihr Datenformat dargestellt werden soll. Anschließend wird eine Darstellung Ihrer Daten im Glue-Datenkatalog gespeichert, die in einem AWS AWS Glue-ETL-Skript verwendet werden kann, um Ihre Daten mit der `GlueContext.create_dynamic_frame.from_catalog` Methode abzurufen. Crawler machen es überflüssig, Informationen über Ihr Datenformat manuell anzugeben. AWS GlueUnterstützt für Jobs, die auf AWS Lake Formation gesteuerte Tabellen zugreifen, das Lesen und Schreiben aller Formate, die von Lake Formation verwalteten Tabellen unterstützt werden. Die aktuelle Liste der unterstützten Formate für gesteuerte AWS Lake Formation Tabellen finden Sie unter [Hinweise und Einschränkungen für verwaltete Tabellen](https://docs.aws.amazon.com/lake-formation/latest/dg/governed-table-restrictions.html) im *AWS Lake Formation Entwicklerhandbuch*. **Anmerkung** Zum Schreiben von Apache Parquet unterstützt AWS Glue ETL das Schreiben in eine verwaltete Tabelle nur, indem eine Option für einen benutzerdefinierten Parquet-Schreibertyp angegeben wird, der für dynamische Frames optimiert ist. Beim Schreiben an eine verwaltete Tabelle mit dem `parquet`-Format sollten Sie den Schlüssel `useGlueParquetWriter` mit einem Wert von `true` den Tabellenparametern hinzufügen. **Topics** + [Funktionsunterstützung für alle Datenformate in AWS Glue](#aws-glue-programming-etl-format-features) + [Parameter, die für die Interaktion mit Datenformaten in AWS Glue verwendet werden](#aws-glue-programming-etl-format-parameters) + [Verwenden des CSV-Formats in AWS Glue](aws-glue-programming-etl-format-csv-home.md) + [Das Parkett-Format in AWS Glue verwenden](aws-glue-programming-etl-format-parquet-home.md) + [Verwenden des XML-Formats in AWS Glue](aws-glue-programming-etl-format-xml-home.md) + [Verwenden des Avro-Formats in Glue AWS](aws-glue-programming-etl-format-avro-home.md) + [Verwenden des GrokLog-Formats in Glue AWS](aws-glue-programming-etl-format-grokLog-home.md) + [Das Ion-Format in AWS Glue verwenden](aws-glue-programming-etl-format-ion-home.md) + [Verwenden des JSON-Formats in AWS Glue](aws-glue-programming-etl-format-json-home.md) + [Verwenden des ORC-Formats in Glue AWS](aws-glue-programming-etl-format-orc-home.md) + [Verwendung von Data-Lake-Frameworks mit AWS Glue ETL-Jobs](aws-glue-programming-etl-datalake-native-frameworks.md) + [Freigegebene Konfigurationsreferenz](#aws-glue-programming-etl-format-shared-reference) # Verwenden des CSV-Formats in AWS Glue AWS Glue ruft Daten aus Quellen ab und schreibt Daten auf Ziele, die in verschiedenen Datenformaten gespeichert und transportiert werden. Wenn Ihre Daten im CSV-Datenformat gespeichert oder transportiert werden, stellt Ihnen dieses Dokument die verfügbaren Funktionen für die Verwendung Ihrer Daten in AWS Glue vor. AWS Glue unterstützt die Verwendung des CSV-Formats (Comma-Separated Value). Dieses Format ist ein minimales, zeilenbasiertes Datenformat. CSVs entsprechen oft nicht strikt einem Standard, aber weitere Informationen finden Sie in [RFC 4180 und [RFC](https://tools.ietf.org/html/rfc7111)](https://tools.ietf.org/html/rfc4180) 7111. Sie können AWS Glue verwenden, um CSVs aus Amazon S3 und aus Streaming-Quellen zu lesen sowie in Amazon S3 CSVs zu schreiben. Sie können `bzip`- und `gzip`-Archive mit CSV-Dateien aus S3 lesen und schreiben. Sie konfigurieren das Komprimierungsverhalten auf [S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) statt in der auf dieser Seite besprochenen Konfiguration. Die folgende Tabelle zeigt, welche gängigen AWS Glue-Funktionen die CSV-Formatoption unterstützen. | Lesen | Write (Schreiben) | Streaming gelesen | Gruppieren von kleinen Dateien | Auftrags-Lesezeichen | | --- | --- | --- | --- | --- | | Unterstützt | Unterstützt | Unterstützt | Unterstützt | Unterstützt | ## Beispiel: Lesen von CSV-Dateien oder Ordnern aus S3 **Voraussetzungen:** Sie benötigen die S3-Pfade (`s3path`) zu den CSV-Dateien oder Ordnern, die Sie lesen möchten. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="csv"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um `s3path` anzugeben. Sie können konfigurieren, wie der Reader mit S3 in `connection_options` interagiert. Einzelheiten finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Sie können konfigurieren, wie der Reader CSV-Dateien in Ihrem `format_options` interpretiert. Einzelheiten finden Sie unter [CSV-Konfigurationsreferenz](#aws-glue-programming-etl-format-csv-reference). Das folgende AWS Glue-ETL-Skript zeigt den Vorgang des Lesens von CSV-Dateien oder -Ordnern aus S3. Wir bieten einen benutzerdefinierten CSV-Reader mit Leistungsoptimierungen für gängige Workflows über den `optimizePerformance`-Konfigurationsschlüssel. Um festzustellen, ob dieser Reader für Ihren Workload geeignet ist, lesen Sie [Optimieren der Leseleistung mit vektorisiertem SIMD-CSV-Leser](#aws-glue-programming-etl-format-simd-csv-reader). ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read CSV from S3 # For show, we handle a CSV with a header row. Set the withHeader option. # Consider whether optimizePerformance is right for your workflow. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) spark = glueContext.spark_session dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="csv", format_options={ "withHeader": True, # "optimizePerformance": True, }, ) ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` dataFrame = spark.read\ .format("csv")\ .option("header", "true")\ .load("s3://s3path") ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die Operation [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read CSV from S3 // For show, we handle a CSV with a header row. Set the withHeader option. // Consider whether optimizePerformance is right for your workflow. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"withHeader": true}"""), connectionType="s3", format="csv", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` Sie können es auch DataFrames in einem Skript (`org.apache.spark.sql.DataFrame`) verwenden. ``` val dataFrame = spark.read .option("header","true") .format("csv") .load("s3://s3path“) ``` ------ ## Beispiel: Schreiben von CSV-Dateien und -Ordnern in S3 **Voraussetzungen:** Sie benötigen ein initialisiertes DataFrame (`dataFrame`) oder ein DynamicFrame (`dynamicFrame`). Sie benötigen auch Ihren erwarteten S3-Ausgabepfad, `s3path`. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="csv"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um `s3path` anzugeben. Sie können konfigurieren, wie der Writer mit S3 in `connection_options` interagiert. Einzelheiten finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Sie können konfigurieren, wie Ihre Operation den Inhalt Ihrer Dateien in `format_options` schreibt. Einzelheiten finden Sie unter [CSV-Konfigurationsreferenz](#aws-glue-programming-etl-format-csv-reference). Das folgende AWS -Glue-ETL-Skript zeigt den Prozess des Schreibens von CSV-Dateien und -Ordnern in S3. ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` # Example: Write CSV to S3 # For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", connection_options={"path": "s3://s3path"}, format="csv", format_options={ "quoteChar": -1, }, ) ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` dataFrame.write\ .format("csv")\ .option("quote", None)\ .mode("append")\ .save("s3://s3path") ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getSinkWithFormat-Methode](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` // Example: Write CSV to S3 // For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="csv" ).writeDynamicFrame(dynamicFrame) } } ``` Sie können es auch DataFrames in einem Skript (`org.apache.spark.sql.DataFrame`) verwenden. ``` dataFrame.write .format("csv") .option("quote", null) .mode("Append") .save("s3://s3path") ``` ------ ## CSV-Konfigurationsreferenz Sie können Folgendes verwenden, `format_options` wo immer die AWS Glue-Bibliotheken dies angeben`format="csv"`: + `separator` – Gibt das Trennzeichen an. Der Standardwert ist ein Komma, aber es kann jedes andere Zeichen angegeben werden. + **Typ:** Text, **Standard:** `","` + `escaper` – Gibt ein Zeichen an, das für die Maskierung verwendet werden soll. Diese Option wird nur beim Lesen von CSV-Dateien verwendet, nicht beim Schreiben. Wenn aktiviert, wird das unmittelbar folgende Zeichen unverändert verwendet, mit Ausnahme einiger bekannter Maskierungen (`\n`, `\r`, `\t` und `\0`). + **Typ:** Text, **Standard:** keine + `quoteChar` – Gibt das Zeichen für Anführungszeichen an. Der Standardwert ist ein doppeltes Anführungszeichen. Setzen Sie dies auf `-1`, um Anführungszeichen generell zu deaktivieren. + **Typ:** Text, **Standard:** `'"'` + `multiLine` – Gibt an, ob ein einzelner Datensatz mehrere Zeilen umfassen kann. Dies kommt vor, wenn ein Feld ein Neue-Zeile-Zeichen in Anführungszeichen enthält. Sie müssen diese Option auf "`True` setzen, wenn ein Datensatz mehrere Zeilen umfasst. Das Aktivieren von `multiLine` kann die Leistung verringern, da beim Parsen eine vorsichtigere Dateiaufteilung erforderlich ist. + **Typ:** Boolesch, **Standard:** `false` + `withHeader` – Gibt an, ob die erste Zeile als Kopfzeile behandelt werden soll. Diese Option kann in der `DynamicFrameReader`-Klasse verwendet werden. + **Typ:** Boolesch, **Standard:** `false` + `writeHeader` – Gibt an, ob die Kopfzeile ausgegeben werden soll. Diese Option kann in der `DynamicFrameWriter`-Klasse verwendet werden. + **Typ:** Boolesch, **Standard:** `true` + `skipFirst` – Gibt an, ob die erste Datenzeile übersprungen werden soll. + **Typ:** Boolesch, **Standard:** `false` + `optimizePerformance` – Gibt an, ob der erweiterte SIMD-CSV-Reader zusammen mit Apache-Arrow-basierten Spaltenspeicherformaten verwendet werden soll. Nur verfügbar in AWS Glue 3.0\$1. + **Typ:** Boolesch, **Standard:** `false` + `strictCheckForQuoting`— Beim Schreiben kann Glue Werte CSVs, die es als Zeichenketten interpretiert, in Anführungszeichen setzen. Dies geschieht, um Unklarheiten beim Ausschreiben zu vermeiden. Um bei der Entscheidung, was geschrieben werden soll, Zeit zu sparen, zitiert Glue möglicherweise in bestimmten Situationen, in denen Anführungszeichen nicht erforderlich sind. Durch die Aktivierung einer strengen Prüfung wird eine intensivere Berechnung durchgeführt und es werden nur Angebote erstellt, wenn dies unbedingt erforderlich ist. Nur verfügbar in AWS Glue 3.0\$1. + **Typ:** Boolesch, **Standard:** `false` ## Optimieren der Leseleistung mit vektorisiertem SIMD-CSV-Leser AWS Glue-Version 3.0 fügt einen optimierten CSV-Reader hinzu, der die Gesamtleistung des Auftrags im Vergleich zu zeilenbasierten CSV-Readern erheblich beschleunigen kann. Der optimierte Reader: + Verwendet CPU-SIMD-Anweisungen zum Lesen von der Festplatte + Schreibt sofort Datensätze in einem Spaltenformat in den Speicher (Apache Arrow) + Teilt die Datensätze in Batches auf Dies spart Verarbeitungszeit, wenn die Datensätze später in Batches oder in ein Spaltenformat konvertiert werden sollen. Einige Beispiele sind das Ändern von Schemas oder das Abrufen von Daten nach Spalte. Um den optimierten Reader zu verwenden, setzen Sie `"optimizePerformance"` auf `true` in der `format_options`- oder Tabelleneigenschaft. ``` glueContext.create_dynamic_frame.from_options( frame = datasource1, connection_type = "s3", connection_options = {"paths": ["s3://s3path"]}, format = "csv", format_options={ "optimizePerformance": True, "separator": "," }, transformation_ctx = "datasink2") ``` **Einschränkungen für den vektorisierten CSV-Reader** Beachten Sie die folgenden Einschränkungen des vektorisierten CSV-Readers: + Die Formatoptionen `multiLine` und `escaper` werden nicht unterstützt. Es wird der Standard `escaper` doppelter Anführungszeichen `'"'` verwendet. Wenn diese Optionen festgelegt sind, fällt AWS Glue automatisch auf die Verwendung des zeilenbasierten CSV-Readers zurück. + Es unterstützt nicht das Erstellen eines DynamicFrame mit [ChoiceType](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-extensions-types.html#aws-glue-api-crawler-pyspark-extensions-types-awsglue-choicetype). + Das Erstellen von [Datensätzen DynamicFrame mit Fehlern wird](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame) nicht unterstützt. + Das Lesen von CSV-Dateien mit Multibyte-Zeichen wie japanischen oder chinesischen Zeichen wird nicht unterstützt. # Das Parkett-Format in AWS Glue verwenden AWS Glue ruft Daten aus Quellen ab und schreibt Daten auf Ziele, die in verschiedenen Datenformaten gespeichert und transportiert werden. Wenn Ihre Daten im Parquet-Datenformat gespeichert oder transportiert werden, stellt Ihnen dieses Dokument die verfügbaren Funktionen für die Verwendung Ihrer Daten in AWS Glue vor. AWS Glue unterstützt die Verwendung des Parquet-Formats. Dieses Format ist ein leistungsorientiertes, spaltenbasiertes Datenformat. Eine Einführung in das Format durch die Standardautorität finden Sie unter [Dokumentationsübersicht zu Apache-Parquet](https://parquet.apache.org/docs/overview/). Sie können AWS Glue verwenden, um Parquet-Dateien von Amazon S3 und aus Streaming-Quellen zu lesen sowie Parquet-Dateien auf Amazon S3 zu schreiben. Sie können `bzip`- und `gzip`-Archive mit Parquet-Dateien aus S3 lesen und schreiben. Sie konfigurieren das Komprimierungsverhalten auf [S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) statt in der auf dieser Seite besprochenen Konfiguration. Die folgende Tabelle zeigt, welche gängigen Funktionen von AWS Glue die Formatoption Parquet unterstützen. | Lesen | Write (Schreiben) | Streaming gelesen | Gruppieren von kleinen Dateien | Auftrags-Lesezeichen | | --- | --- | --- | --- | --- | | Unterstützt | Unterstützt | Unterstützt | Nicht unterstützt | Unterstützt\$1 | \$1 Wird in AWS Glue Version 1.0\$1 unterstützt ## Beispiel: Lesen von Parquet-Dateien oder -Ordnern aus S3 ** Voraussetzungen:** Sie benötigen die S3-Pfade (`s3path`) zu den Parquet-Dateien oder -Ordnern, die Sie lesen möchten. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="parquet"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um Ihren `s3path` anzugeben. Sie können konfigurieren, wie der Reader mit S3 in der `connection_options` interagiert. Einzelheiten finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Sie können konfigurieren, wie der Reader Parquet-Dateien in Ihrem `format_options` interpretiert. Details dazu finden Sie unter [Parquet-Konfigurationsreferenz](#aws-glue-programming-etl-format-parquet-reference). Das folgende AWS Glue-ETL-Skript zeigt den Vorgang des Lesens von Parquet-Dateien oder -Ordnern aus S3: ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read Parquet from S3 from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) spark = glueContext.spark_session dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type = "s3", connection_options = {"paths": ["s3://s3path/"]}, format = "parquet" ) ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` dataFrame = spark.read.parquet("s3://s3path/") ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getSourceWithFormat-Methode](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read Parquet from S3 import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( connectionType="s3", format="parquet", options=JsonOptions("""{"paths": ["s3://s3path"]}""") ).getDynamicFrame() } } ``` Sie können auch DataFrames in einem Skript (`org.apache.spark.sql.DataFrame`) verwenden. ``` spark.read.parquet("s3://s3path/") ``` ------ ## Beispiel: Schreiben von Parquet-Dateien und -Ordnern nach S3 **Voraussetzungen:** Sie benötigen ein initialisiertes DataFrame (`dataFrame`) oder DynamicFrame (`dynamicFrame`). Sie benötigen auch Ihren erwarteten S3-Ausgabepfad, `s3path`. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="parquet"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um `s3path` anzugeben. Sie können die Art und Weise, wie der Writer mit S3 in `connection_options` interagiert, weiter verändern. Einzelheiten finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Sie können konfigurieren, wie Ihre Operation den Inhalt Ihrer Dateien in `format_options` schreibt. Details dazu finden Sie unter [Parquet-Konfigurationsreferenz](#aws-glue-programming-etl-format-parquet-reference). Das folgende AWS Glue-ETL-Skript zeigt den Vorgang des Schreibens von Parquet-Dateien und -Ordnern nach S3. Wir bieten über den `useGlueParquetWriter` Konfigurationsschlüssel einen benutzerdefinierten Parquet-Writer mit Leistungsoptimierungen für DynamicFrames. Um festzustellen, ob dieser Writer für Ihren Workload geeignet ist, lesen Sie [Glue-Parquet-Writer](#aws-glue-programming-etl-format-glue-parquet-writer). ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` # Example: Write Parquet to S3 # Consider whether useGlueParquetWriter is right for your workflow. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", format="parquet", connection_options={ "path": "s3://s3path", }, format_options={ # "useGlueParquetWriter": True, }, ) ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` df.write.parquet("s3://s3path/") ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getSinkWithFormat-Methode](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` // Example: Write Parquet to S3 // Consider whether useGlueParquetWriter is right for your workflow. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="parquet" ).writeDynamicFrame(dynamicFrame) } } ``` Sie können auch DataFrames in einem Skript (`org.apache.spark.sql.DataFrame`) verwenden. ``` df.write.parquet("s3://s3path/") ``` ------ ## Parquet-Konfigurationsreferenz Sie können Folgendes verwenden, `format_options` wo immer die AWS Glue-Bibliotheken dies angeben`format="parquet"`: + `useGlueParquetWriter`— Gibt die Verwendung eines benutzerdefinierten Parquet-Writers an, der Leistungsoptimierungen für DynamicFrame Workflows bietet. Einzelheiten zur Verwendung finden Sie unter [Glue-Parquet-Writer](#aws-glue-programming-etl-format-glue-parquet-writer). + **Typ:** Boolesch, **Standard:**`false` + `compression` – Gibt den verwendeten Komprimierungs-Codec an. Werte sind voll kompatibel mit `org.apache.parquet.hadoop.metadata.CompressionCodecName`. + **Typ:** Aufzählungstext, **Standard:** `"snappy"` + Werte: `"uncompressed"`, `"snappy"`, `"gzip"` und `"lzo"` + `blockSize` – Gibt die Größe einer im Arbeitsspeicher gepufferten Zeilengruppe in Bytes an. Sie verwenden dies, um die Leistung zu optimieren. Die Größe sollte sich genau in eine Anzahl von Megabyte teilen. + **Typ:** Numerisch, **Standard:**`134217728` + Der Standardwert ist gleich 128 MB. + `pageSize` – Gibt die Größe einer Seite in Byte an. Sie verwenden dies, um die Leistung zu optimieren. Eine Seite ist die kleinste Einheit, die vollständig gelesen werden muss, um auf einen einzelnen Datensatz zugreifen zu können. + **Typ:** Numerisch, **Standard:**`1048576` + Der Standardwert ist gleich 1 MB. **Anmerkung** Es können zusätzlich alle Optionen, die vom zugrunde liegenden SparkSQL-Code akzeptiert werden, im Rahmen des `connection_options`-Map-Parameters in dieses Format übergeben werden. Zum Beispiel kann eine Spark-Konfiguration wie [mergeSchema](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#schema-merging) für den AWS Glue Spark-Reader so eingestellt werden, dass das Schema für alle Dateien zusammengeführt wird. ## Optimieren Sie die Schreibleistung mit dem AWS Glue Parquet Writer **Anmerkung** Der AWS Glue Parquet-Writer wurde in der Vergangenheit über den `glueparquet` Formattyp aufgerufen. Dieses Zugriffsmuster wird nicht mehr befürwortet. Verwenden Sie stattdessen den `parquet`-Typ mit aktiviertem `useGlueParquetWriter`. Der AWS Glue Parquet-Writer verfügt über Leistungsverbesserungen, die schnellere Schreibvorgänge in Parquet-Dateien ermöglichen. Der traditionelle Writer berechnet vor dem Schreiben ein Schema. Das Parquet-Format speichert das Schema nicht in einer schnell abrufbaren Form, daher kann dies einige Zeit dauern. Mit dem AWS Glue Parquet Writer ist kein vorberechnetes Schema erforderlich. Der Writer berechnet und modifiziert das Schema dynamisch, sobald Daten eingehen. Beachten Sie die folgenden Einschränkungen, wenn Sie `useGlueParquetWriter` angeben: + Der Writer unterstützt nur die Schemaentwicklung (z. B. das Hinzufügen oder Entfernen von Spalten), aber nicht das Ändern von Spaltentypen, wie bei `ResolveChoice`. + Der Writer unterstützt kein leeres Schreiben, z. DataFrames B. um eine reine Schemadatei zu schreiben. Bei der Integration mit dem AWS Glue-Datenkatalog per Einstellung wird der Datenkatalog nicht aktualisiert`enableUpdateCatalog=True`, wenn versucht DataFrame wird, ein leeres Feld zu schreiben. Dies führt dazu, dass im Datenkatalog eine Tabelle ohne Schema erstellt wird. Wenn Ihre Transformation diese Einschränkungen nicht erfordert, sollte das Einschalten des AWS Glue Parquet-Writers die Leistung erhöhen. # Verwenden des XML-Formats in AWS Glue AWS Glue ruft Daten aus Quellen ab und schreibt Daten auf Ziele, die in verschiedenen Datenformaten gespeichert und transportiert werden. Wenn Ihre Daten im XML-Datenformat gespeichert oder transportiert werden, stellt Ihnen dieses Dokument die verfügbaren Funktionen für die Verwendung Ihrer Daten in AWS Glue vor. AWS Glue unterstützt die Verwendung des XML-Formats. Dieses Format stellt hochgradig konfigurierbare, fest definierte Datenstrukturen dar, die nicht zeilen- oder spaltenbasiert sind. XML ist hochgradig standardisiert. Eine Einführung in das Format durch die Standardautorität finden Sie unter [XML Essentials](https://www.w3.org/standards/xml/core). Sie können AWS Glue verwenden, um XML-Dateien aus Amazon S3 `bzip` sowie `gzip` Archive, die XML-Dateien enthalten, zu lesen. Sie konfigurieren das Komprimierungsverhalten auf [S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) statt in der auf dieser Seite besprochenen Konfiguration. Die folgende Tabelle zeigt, welche gängigen AWS Glue-Funktionen die XML-Formatoption unterstützen. | Lesen | Write (Schreiben) | Streaming gelesen | Gruppieren von kleinen Dateien | Auftrags-Lesezeichen | | --- | --- | --- | --- | --- | | Unterstützt | Nicht unterstützt | Nicht unterstützt | Unterstützt | Unterstützt | ## Beispiel: Lesen von XML aus S3 Der XML-Reader akzeptiert einen XML-Tag-Namen. Es untersucht Elemente mit diesem Tag in der Eingabe, um daraus ein Schema abzuleiten, und füllt a DynamicFrame mit entsprechenden Werten auf. Die AWS Glue-XML-Funktionalität verhält sich ähnlich wie die [XML-Datenquelle für Apache Spark](https://github.com/databricks/spark-xml). Möglicherweise können Sie einen Einblick in das grundlegende Verhalten gewinnen, indem Sie diesen Reader mit der Dokumentation dieses Projekts vergleichen. ** Voraussetzungen:** Sie benötigen die S3-Pfade (`s3path`) zu den XML-Dateien oder -Ordnern, die Sie lesen möchten, sowie einige Informationen zu Ihrer XML-Datei. Sie benötigen auch das Tag für das XML-Element, das Sie lesen möchten, `xmlTag`. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="xml"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um `s3path` anzugeben. Sie können weiter konfigurieren, wie der Reader mit S3 in `connection_options` interagiert. Einzelheiten finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Verwenden Sie in Ihrem `format_options` den `rowTag`-Schlüssel, um `xmlTag` anzugeben. Sie können weiter konfigurieren, wie der Reader mit XML-Dateien in `format_options` interagiert. Einzelheiten finden Sie in der [XML-Konfigurationsreferenz](#aws-glue-programming-etl-format-xml-reference). Das folgende AWS -Glue-ETL-Skript zeigt den Prozess des Lesens von XML-Dateien oder -Ordnern aus S3. ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read XML from S3 # Set the rowTag option to configure the reader. from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="xml", format_options={"rowTag": "xmlTag"}, ) ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` dataFrame = spark.read\ .format("xml")\ .option("rowTag", "xmlTag")\ .load("s3://s3path") ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die Operation [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read XML from S3 // Set the rowTag option to configure the reader. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.sql.SparkSession val glueContext = new GlueContext(SparkContext.getOrCreate()) val sparkSession: SparkSession = glueContext.getSparkSession object GlueApp { def main(sysArgs: Array[String]): Unit = { val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"rowTag": "xmlTag"}"""), connectionType="s3", format="xml", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } ``` Sie können es auch DataFrames in einem Skript (`org.apache.spark.sql.DataFrame`) verwenden. ``` val dataFrame = spark.read .option("rowTag", "xmlTag") .format("xml") .load("s3://s3path“) ``` ------ ## XML-Konfigurationsreferenz Sie können Folgendes verwenden, `format_options` wo immer die AWS Glue-Bibliotheken dies angeben`format="xml"`: + `rowTag` – Gibt an, dass der XML-Tag in der Datei als Zeile zu behandeln ist. Zeilen-Tags können nicht selbstschließend sein. + **Typ:** Text, **Erforderlich** + `encoding` – Gibt die Zeichencodierung an. Dies kann der Name oder Alias eines von unserer Laufzeitumgebung unterstützten [Zeichensatzes](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html) sein. Wir geben keine spezifischen Garantien für die Unterstützung der Codierung, aber wichtige Kodierungen sollten funktionieren. + **Typ:** Text, **Standard:** `"UTF-8"` + `excludeAttribute` – Gibt an, ob Sie Attribute in Elementen ausschließen möchten oder nicht. + **Typ:** Boolesch, **Standard:** `false` + `treatEmptyValuesAsNulls` – Gibt an, ob Leerzeichen als Nullwert behandelt werden sollen. + **Typ:** Boolesch, **Standard:** `false` + `attributePrefix` – Ein Präfix für Attribute, um sie vom Text der untergeordneten Elemente zu unterscheiden. Das Präfix wird für Feldnamen verwendet. + **Typ:** Text, **Standard:** `"_"` + `valueTag` – Das Tag, das für einen Wert verwendet wird, wenn das Element Attribute enthält, die kein untergeordnetes Element haben. + **Typ:** Text, **Standard:** `"_VALUE"` + `ignoreSurroundingSpaces` – Gibt an, ob das Leerzeichen, das die Werte umgibt, ignoriert werden soll. + **Typ:** Boolesch, **Standard:** `false` + `withSchema` – Enthält das erwartete Schema in Situationen, in denen Sie das abgeleitete Schema überschreiben möchten. Wenn Sie diese Option nicht verwenden, leitet AWS Glue das Schema aus den XML-Daten ab. + **Typ:** Text, **Standard:** Nicht zutreffend + Der Wert sollte ein JSON-Objekt sein, das ein `StructType` darstellt. ## Geben Sie das XML-Schema manuell an **Beispiel eines manuellen XML-Schemas** Dies ist ein Beispiel für die Verwendung der Formatoption `withSchema`, um das Schema für XML-Daten anzugeben. ``` from awsglue.gluetypes import * schema = StructType([ Field("id", IntegerType()), Field("name", StringType()), Field("nested", StructType([ Field("x", IntegerType()), Field("y", StringType()), Field("z", ChoiceType([IntegerType(), StringType()])) ])) ]) datasource0 = create_dynamic_frame_from_options( connection_type, connection_options={"paths": ["s3://xml_bucket/someprefix"]}, format="xml", format_options={"withSchema": json.dumps(schema.jsonValue())}, transformation_ctx = "" ) ``` # Verwenden des Avro-Formats in Glue AWS AWS Glue ruft Daten aus Quellen ab und schreibt Daten auf Ziele, die in verschiedenen Datenformaten gespeichert und transportiert werden. Wenn Ihre Daten im Avro-Datenformat gespeichert oder transportiert werden, werden Ihnen in diesem Dokument die verfügbaren Funktionen für die Verwendung Ihrer Daten in AWS Glue vorgestellt. AWS Glue unterstützt die Verwendung des Avro-Formats. Dieses Format ist ein leistungsorientiertes, zeilenbasiertes Datenformat. Eine Einführung in das Format durch die Standardautorität finden Sie unter der [Apache-Avro 1.8.2 Dokumentation](https://avro.apache.org/docs/1.8.2/). Sie können AWS Glue verwenden, um Avro-Dateien von Amazon S3 und aus Streaming-Quellen zu lesen sowie Avro-Dateien auf Amazon S3 zu schreiben. Sie können `bzip2`- und `gzip`-Archive mit Avro-Dateien aus S3 lesen und schreiben. Darüber hinaus können Sie `deflate`-, `snappy`-, und `xz`-Archive schreiben, die Avro-Dateien enthalten. Sie konfigurieren das Komprimierungsverhalten auf [S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) statt in der auf dieser Seite besprochenen Konfiguration. Die folgende Tabelle zeigt, welche gängigen AWS Glue-Operationen die Avro-Formatoption unterstützen. | Lesen | Write (Schreiben) | Streaming gelesen | Gruppieren von kleinen Dateien | Auftrags-Lesezeichen | | --- | --- | --- | --- | --- | | Unterstützt | Unterstützt | Unterstützt\$1 | Nicht unterstützt | Unterstützt | \$1Mit Einschränkungen unterstützt. Weitere Informationen finden Sie unter [Hinweise und Einschränkungen für Avro-Streaming-Quellen](add-job-streaming.md#streaming-avro-notes). ## Beispiel: Lesen von Avro-Dateien oder Ordnern aus S3 ** Voraussetzungen:** Sie benötigen die S3-Pfade (`s3path`) zu den Avro-Dateien oder Ordnern, die Sie lesen möchten. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="avro"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um `s3path` anzugeben. Sie können konfigurieren, wie der Reader mit S3 in der `connection_options` interagiert. Einzelheiten finden Sie unter Datenformatoptionen für ETL-Eingaben und -Ausgaben in AWS Glue:[Referenz zur Amazon-S3-Verbindungsoption](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Sie können konfigurieren, wie der Reader Avro-Dateien in Ihrem `format_options` interpretiert. Einzelheiten finden Sie in der [Avro-Konfigurationsreferenz](#aws-glue-programming-etl-format-avro-reference). Das folgende AWS Glue-ETL-Skript zeigt den Vorgang des Lesens von Avro-Dateien oder -Ordnern aus S3: ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="avro" ) ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die Operation [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.sql.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( connectionType="s3", format="avro", options=JsonOptions("""{"paths": ["s3://s3path"]}""") ).getDynamicFrame() } ``` ------ ## Beispiel: Schreiben von Avro-Dateien und -Ordnern in S3 **Voraussetzungen:** Sie benötigen ein initialisiertes DataFrame (`dataFrame`) oder DynamicFrame (`dynamicFrame`). Sie benötigen auch Ihren erwarteten S3-Ausgabepfad, `s3path`. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="avro"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um Ihren `s3path` anzugeben. Sie können die Art und Weise, wie der Writer mit S3 in `connection_options` interagiert, weiter verändern. Einzelheiten finden Sie unter Datenformatoptionen für ETL-Eingaben und -Ausgaben in AWS Glue:[Referenz zur Amazon-S3-Verbindungsoption](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Sie können ändern, wie der Schreiber Avro-Dateien in Ihren `format_options` interpretiert. Einzelheiten finden Sie in der [Avro-Konfigurationsreferenz](#aws-glue-programming-etl-format-avro-reference). Das folgende AWS Glue-ETL-Skript zeigt den Vorgang des Schreibens von Avro-Dateien oder -Ordnern nach S3. ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", format="avro", connection_options={ "path": "s3://s3path" } ) ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getSinkWithFormat-Methode](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="avro" ).writeDynamicFrame(dynamicFrame) } } ``` ------ ## Avro-Konfigurationsreferenz Sie können die folgenden `format_options` Werte überall dort verwenden, wo AWS Glue-Bibliotheken dies angeben`format="avro"`: + `version`— Gibt die Version des Apache reader/writer Avro-Formats an, die unterstützt werden soll. Der Standardwert ist "1.7". Sie können `format_options={"version": “1.8”}` angeben, um das Lesen und Schreiben des logischen Avro-Typs zu ermöglichen. Weitere Informationen finden Sie unter [Apache Avro 1.7.7 Specification](https://avro.apache.org/docs/1.7.7/spec.html) und [Apache Avro 1.8.2 Specification](https://avro.apache.org/docs/1.8.2/spec.html). Der Apache Avro 1.8-Konnektor unterstützt die folgenden Konvertierungen für logische Typen: Für den Reader zeigt diese Tabelle die Konvertierung zwischen Avro-Datentyp (logischer Typ und primitiver Avro-Typ) und dem Datentyp AWS Glue `DynamicFrame` für Avro Reader 1.7 und 1.8 an. | Avro-Datentyp: Logischer Typ | Avro-Datentyp: Primitiver Avro-Typ | GlueDynamicFrame Datentyp:Avro Reader 1.7 | GlueDynamicFrame Datentyp: Avro Reader 1.8 | | --- | --- | --- | --- | | Dezimal | bytes | BINARY | Dezimal | | Dezimal | Fixed | BINARY | Dezimal | | Date | int | INT | Date | | Zeit (Millisekunde) | int | INT | INT | | Zeit (Mikrosekunde) | long | LONG | LONG | | Zeitstempel (Millisekunde) | long | LONG | Zeitstempel | | Zeitstempel (Mikrosekunde) | long | LONG | LONG | | Dauer (kein logischer Typ) | Fixed von 12 | BINARY | BINARY | Für Writer zeigt diese Tabelle die Konvertierung zwischen dem Datentyp AWS Glue `DynamicFrame` und dem Avro-Datentyp für Avro Writer 1.7 und 1.8 an. | AWS GlueDatentyp`DynamicFrame` | Avro-Datentyp:Avro Writer 1.7 | Avro-Datentyp:Avro Writer 1.8 | | --- | --- | --- | | Dezimal | Zeichenfolge | Dezimalwert | | Date | Zeichenfolge | date | | Zeitstempel | Zeichenfolge | timestamp-micros | ## Avro Spark-Unterstützung DataFrame Um Avro über die DataFrame Spark-API verwenden zu können, müssen Sie das Spark Avro-Plugin für die entsprechende Spark-Version installieren. Welche Version von Spark in Ihrem Job verfügbar ist, hängt von Ihrer AWS Glue-Version ab. Weitere Informationen zu den Spark-Versionen erhalten Sie unter [AWS Glue Versionen](release-notes.md). Dieses Plugin wird von Apache verwaltet, wir geben keine spezifischen Garantien für den Support. Verwenden AWS Sie in Glue 2.0 Version 2.4.3 des Spark Avro-Plugins. Sie finden dieses JAR auf Maven Central, siehe [org.apache.spark:spark-avro\$12.12:2.4.3](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar). Verwenden AWS Sie in Glue 3.0 Version 3.1.1 des Spark Avro-Plugins. Sie finden dieses JAR auf Maven Central, siehe [org.apache.spark:spark-avro\$12.12:3.1.1](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar). Verwenden Sie den Job-Parameter, um zusätzliche Elemente JARs in einen AWS `--extra-jars` Glue-ETL-Job aufzunehmen. Informationen zu Auftragsparametern finden Sie unter [Verwenden von Auftragsparametern in AWS Glue-Jobs](aws-glue-programming-etl-glue-arguments.md). Sie können diesen Parameter auch in AWS-Managementkonsole konfigurieren. # Verwenden des GrokLog-Formats in Glue AWS AWS Glue ruft Daten aus Quellen ab und schreibt Daten auf Ziele, die in verschiedenen Datenformaten gespeichert und transportiert werden. Wenn Ihre Daten in einem locker strukturierten Klartextformat gespeichert oder transportiert werden, werden Ihnen in diesem Dokument die verfügbaren Funktionen für die Verwendung Ihrer Daten in AWS Glue-through-Grok-Mustern vorgestellt. AWS Glue unterstützt die Verwendung von Grok-Mustern. Grok-Muster ähneln Erfassungsgruppen mit regulären Ausdrücken. Sie erkennen Muster von Zeichenfolgen in einer Klartextdatei und geben ihnen einen Typ und Zweck. In AWS Glue besteht ihr Hauptzweck darin, Protokolle zu lesen. Eine Einführung in den Grok durch die Autoren finden Sie unter [Logstash-Referenz: Grok-Filter-Plugin](https://www.elastic.co/guide/en/logstash/current/plugins-filters-grok.html). | Lesen | Write (Schreiben) | Streaming gelesen | Gruppieren von kleinen Dateien | Auftrags-Lesezeichen | | --- | --- | --- | --- | --- | | Unterstützt | Nicht zutreffend | Unterstützt | Unterstützt | Nicht unterstützt | ## grokLog-Konfigurationsreferenz Sie können folgende `format_options`-Werte mit `format="grokLog"` verwenden: + `logFormat` – Gibt das Grok-Muster an, das mit dem Protokollformat übereinstimmt. + `customPatterns` – Gibt zusätzliche hier verwendete Grok-Muster an. + `MISSING` – Gibt das Signal für die Identifizierung fehlender Werte an. Der Standardwert ist `'-'`. + `LineCount` – Gibt die Anzahl der Zeilen in den einzelnen Protokolldatensätzen an. Der Standard ist `'1'`. Derzeit werden nur einzeilige Datensätze unterstützt. + `StrictMode` – Ein boolescher Wert, der angibt, ob der Strict-Modus aktiviert ist. Im strikten Modus führt der Reader keine automatische Typkonvertierung oder -wiederherstellung durch. Der Standardwert ist `"false"`. # Das Ion-Format in AWS Glue verwenden AWS Glue ruft Daten aus Quellen ab und schreibt Daten auf Ziele, die in verschiedenen Datenformaten gespeichert und transportiert werden. Wenn Ihre Daten im Ion-Datenformat gespeichert oder transportiert werden, stellt Ihnen dieses Dokument die verfügbaren Funktionen für die Verwendung Ihrer Daten in AWS Glue vor. AWS Glue unterstützt die Verwendung des Ion-Formats. Dieses Format stellt Datenstrukturen (die nicht zeilen- oder spaltenbasiert sind) in austauschbaren Binär- und Klartext-Darstellungen dar. Eine Einführung in das Format durch die Autoren finden Sie unter [Amazon Ion](https://amzn.github.io/ion-docs/). (Weitere Informationen finden Sie in der [Amazon Ion-Spezifikation](https://amzn.github.io/ion-docs/spec.html).) Sie können AWS Glue verwenden, um Ion-Dateien von Amazon S3 zu lesen. Sie können `bzip`- und `gzip`-Archive mit Ion-Dateien aus S3 lesen. Sie konfigurieren das Komprimierungsverhalten auf [S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) statt in der auf dieser Seite besprochenen Konfiguration. Die folgende Tabelle zeigt, welche gängigen AWS Glue-Operationen die Ion-Formatoption unterstützen. | Lesen | Write (Schreiben) | Streaming gelesen | Gruppieren von kleinen Dateien | Auftrags-Lesezeichen | | --- | --- | --- | --- | --- | | Unterstützt | Nicht unterstützt | Nicht unterstützt | Unterstützt | Nicht unterstützt | ## Beispiel: Lesen von Ion-Dateien und Ordnern aus S3 ** Voraussetzungen:** Sie benötigen die S3-Pfade (`s3path`) zu den Ion-Dateien oder -Ordnern, die Sie lesen möchten. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="json"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um Ihren `s3path` anzugeben. Sie können konfigurieren, wie der Reader mit S3 in der `connection_options` interagiert. Einzelheiten finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[Referenz zur Amazon-S3-Verbindungsoption](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Das folgende AWS Glue-ETL-Skript zeigt den Vorgang des Lesens von Ion-Dateien oder -Ordnern aus S3: ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read ION from S3 from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="ion" ) ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die Operation [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read ION from S3 import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( connectionType="s3", format="ion", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` ------ ## Ion-Konfigurationsreferenz Es gibt keine `format_options`-Werte für `format="ion"`. # Verwenden des JSON-Formats in AWS Glue AWS Glue ruft Daten aus Quellen ab und schreibt Daten auf Ziele, die in verschiedenen Datenformaten gespeichert und transportiert werden. Wenn Ihre Daten im JSON-Datenformat gespeichert oder transportiert werden, stellt Ihnen dieses Dokument die verfügbaren Funktionen für die Verwendung Ihrer Daten in AWS Glue vor. AWS Glue unterstützt die Verwendung des JSON-Formats. Dieses Format stellt Datenstrukturen mit einheitlicher Form, aber flexiblem Inhalt dar, die nicht zeilen- oder spaltenbasiert sind. JSON wird durch parallel Standards definiert, die von mehreren Behörden herausgegeben werden, von denen eine ECMA-404 ist. Eine Einführung in das Format durch eine häufig referenzierte Quelle finden Sie unter [Einführung in JSON](https://www.json.org/). Sie können AWS Glue verwenden, um JSON-Dateien aus Amazon S3 `bzip` sowie `gzip` komprimierte JSON-Dateien zu lesen. Sie konfigurieren das Komprimierungsverhalten auf [S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) statt in der auf dieser Seite besprochenen Konfiguration. | Lesen | Write (Schreiben) | Streaming gelesen | Gruppieren von kleinen Dateien | Auftrags-Lesezeichen | | --- | --- | --- | --- | --- | | Unterstützt | Unterstützt | Unterstützt | Unterstützt | Unterstützt | ## Beispiel: Lesen von JSON-Dateien oder Ordnern aus S3 ** Voraussetzungen:** Sie benötigen die S3-Pfade (`s3path`) zu den JSON-Dateien oder Ordnern, die Sie lesen möchten. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="json"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um Ihren `s3path` anzugeben. Sie können in den Verbindungsoptionen weiter ändern, wie Ihr Lesevorgang s3 durchquert, siehe [Referenz zur Amazon-S3-Verbindungsoption](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) für Einzelheiten. Sie können konfigurieren, wie der Reader JSON-Dateien in Ihrem `format_options` interpretiert. Einzelheiten finden Sie in der [JSON-Konfigurationsreferenz](#aws-glue-programming-etl-format-json-reference). Das folgende AWS Glue-ETL-Skript zeigt den Prozess des Lesens von JSON-Dateien oder -Ordnern aus S3: ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read JSON from S3 # For show, we handle a nested JSON file that we can limit with the JsonPath parameter # For show, we also handle a JSON where a single entry spans multiple lines # Consider whether optimizePerformance is right for your workflow. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) spark = glueContext.spark_session dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="json", format_options={ "jsonPath": "$.id", "multiline": True, # "optimizePerformance": True, -> not compatible with jsonPath, multiline } ) ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` dataFrame = spark.read\ .option("multiline", "true")\ .json("s3://s3path") ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die Operation [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read JSON from S3 // For show, we handle a nested JSON file that we can limit with the JsonPath parameter // For show, we also handle a JSON where a single entry spans multiple lines // Consider whether optimizePerformance is right for your workflow. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"jsonPath": "$.id", "multiline": true, "optimizePerformance":false}"""), connectionType="s3", format="json", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` val dataFrame = spark.read .option("multiline", "true") .json("s3://s3path") ``` ------ ## Beispiel: Schreiben von JSON-Dateien und -Ordnern in S3 **Voraussetzungen:** Sie benötigen ein initialisiertes DataFrame (`dataFrame`) oder DynamicFrame (`dynamicFrame`). Sie benötigen auch Ihren erwarteten S3-Ausgabepfad, `s3path`. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="json"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um `s3path` anzugeben. Sie können die Art und Weise, wie der Writer mit S3 in `connection_options` interagiert, weiter verändern. Einzelheiten finden Sie unter Datenformatoptionen für ETL-Eingaben und -Ausgaben in AWS Glue:[Referenz zur Amazon-S3-Verbindungsoption](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Sie können konfigurieren, wie der Writer JSON-Dateien in Ihrem `format_options` interpretiert. Einzelheiten finden Sie in der [JSON-Konfigurationsreferenz](#aws-glue-programming-etl-format-json-reference). Das folgende AWS Glue-ETL-Skript zeigt den Prozess des Schreibens von JSON-Dateien oder -Ordnern aus S3: ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` # Example: Write JSON to S3 from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", connection_options={"path": "s3://s3path"}, format="json" ) ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` df.write.json("s3://s3path/") ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getSinkWithFormat-Methode](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` // Example: Write JSON to S3 import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="json" ).writeDynamicFrame(dynamicFrame) } } ``` Sie können auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` df.write.json("s3://s3path") ``` ------ ## JSON-Konfigurationsreferenz Sie können folgende `format_options`-Werte mit `format="json"` verwenden: + `jsonPath`— Ein [JsonPath](https://github.com/json-path/JsonPath)Ausdruck, der ein Objekt identifiziert, das in Datensätze eingelesen werden soll. Dies ist besonders nützlich, wenn eine Datei Datensätze enthält, die in einem äußeren Array verschachtelt sind. Der folgende JsonPath Ausdruck zielt beispielsweise auf das `id` Feld eines JSON-Objekts ab. ``` format="json", format_options={"jsonPath": "$.id"} ``` + `multiline` – Ein boolescher Wert, der angibt, ob ein einzelner Datensatz mehrere Zeilen umfassen kann. Dies kommt vor, wenn ein Feld ein Neue-Zeile-Zeichen in Anführungszeichen enthält. Sie müssen diese Option auf "`"true"` setzen, wenn ein Datensatz mehrere Zeilen umfasst. Der Standardwert ist `"false"`. Dies ermöglicht eine rigorosere Dateiaufteilung während der Analyse. + `optimizePerformance` – Ein boolescher Wert, der angibt, ob der erweiterte SIMD-JSON-Reader zusammen mit Apache Arrow basierten spaltenförmigen Speicherformaten verwendet werden soll. Nur verfügbar in AWS Glue 3.0. Nicht kompatibel mit `multiline` oder `jsonPath`. Wenn Sie eine dieser Optionen angeben, wird AWS Glue angewiesen, auf den Standardleser zurückzugreifen. + `withSchema` – Ein String-Wert, der ein Tabellenschema in dem in [Geben Sie das XML-Schema manuell an](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema) beschriebenen Format festlegt. Wird nur mit `optimizePerformance` beim Lesen von Nicht-Catalog-Verbindungen verwendet. ## Verwendung vektorisierter SIMD-JSON-Reader mit Apache-Arrow-Spaltenformat AWS Glue-Version 3.0 fügt einen vektorisierten Reader für JSON-Daten hinzu. Er arbeitet unter bestimmten Bedingungen doppelt so schnell als der Standard-Reader. Dieser Reader weist bestimmte Einschränkungen auf, die Benutzer vor der Verwendung beachten sollten und die in diesem Abschnitt dokumentiert werden. Um den optimierten Reader zu verwenden, setzen Sie `"optimizePerformance"` auf True in der `format_options`- oder Tabelleneigenschaft. Sie müssen außerdem `withSchema` angeben, sofern nicht aus dem Katalog gelesen wird. `withSchema` erwartet eine Eingabe wie in der [Geben Sie das XML-Schema manuell an](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema) beschrieben ``` // Read from S3 data source glueContext.create_dynamic_frame.from_options( connection_type = "s3", connection_options = {"paths": ["s3://s3path"]}, format = "json", format_options={ "optimizePerformance": True, "withSchema": SchemaString }) // Read from catalog table glueContext.create_dynamic_frame.from_catalog( database = database, table_name = table, additional_options = { // The vectorized reader for JSON can read your schema from a catalog table property. "optimizePerformance": True, }) ``` Weitere Informationen zum Gebäude a *SchemaString* in der AWS Glue-Bibliothek finden Sie unter[PySpark Erweiterungstypen](aws-glue-api-crawler-pyspark-extensions-types.md). **Einschränkungen für den vektorisierten CSV-Reader** Es gelten die folgenden Einschränkungen: + JSON-Elemente mit verschachtelten Objekten oder Array-Werten werden nicht unterstützt. Falls angegeben, AWS greift Glue auf den Standardleser zurück. + Ein Schema muss bereitgestellt werden, entweder aus dem Katalog oder mit `withSchema`. + Nicht kompatibel mit `multiline` oder `jsonPath`. Wenn Sie eine dieser Optionen angeben, wird AWS Glue angewiesen, auf den Standardleser zurückzugreifen. + Das Bereitstellen von Eingabedatensätzen, die nicht mit dem Eingabeschema übereinstimmen, führt zum Fehlschlagen des Readers. + [Fehler-Aufzeichnungen](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame) werden nicht erstellt. + Das Lesen von JSON-Dateien mit MultiByte-Zeichen (wie japanische oder chinesische Zeichen) wird nicht unterstützt. # Verwenden des ORC-Formats in Glue AWS AWS Glue ruft Daten aus Quellen ab und schreibt Daten auf Ziele, die in verschiedenen Datenformaten gespeichert und transportiert werden. Wenn Ihre Daten im ORC-Datenformat gespeichert oder transportiert werden, stellt Ihnen dieses Dokument die verfügbaren Funktionen für die Verwendung Ihrer Daten in AWS Glue vor. AWS Glue unterstützt die Verwendung des ORC-Formats. Dieses Format ist ein leistungsorientiertes, spaltenbasiertes Datenformat. Eine Einführung in das Format durch die Standardautorität finden Sie unter [Apache Orc](https://orc.apache.org/docs/). Sie können AWS Glue verwenden, um ORC-Dateien von Amazon S3 und aus Streaming-Quellen zu lesen sowie ORC-Dateien auf Amazon S3 zu schreiben. Sie können `bzip`- und `gzip`-Archive mit ORC-Dateien aus S3 lesen und schreiben. Sie konfigurieren das Komprimierungsverhalten auf [S3-Verbindungsparameter](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) statt in der auf dieser Seite besprochenen Konfiguration. Die folgende Tabelle zeigt, welche gängigen AWS Glue-Operationen die ORC-Formatoption unterstützen. | Lesen | Write (Schreiben) | Streaming gelesen | Gruppieren von kleinen Dateien | Auftrags-Lesezeichen | | --- | --- | --- | --- | --- | | Unterstützt | Unterstützt | Unterstützt | Nicht unterstützt | Unterstützt\$1 | \$1 Wird in AWS Glue Version 1.0\$1 unterstützt ## Beispiel: Lesen von ORC-Dateien oder Ordnern aus S3 ** Voraussetzungen:** Sie benötigen die S3-Pfade (`s3path`) zu den ORC-Dateien oder -Ordnern, die Sie lesen möchten. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="orc"` an. Verwenden Sie in Ihrem `connection_options` den `paths`-Schlüssel, um Ihren `s3path` anzugeben. Sie können konfigurieren, wie der Reader mit S3 in der `connection_options` interagiert. Einzelheiten finden Sie unter Verbindungstypen und Optionen für ETL in AWS Glue:[Referenz zur Amazon-S3-Verbindungsoption](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Das folgende AWS Glue-ETL-Skript zeigt den Vorgang des Lesens von ORC-Dateien oder -Ordnern aus S3: ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="orc" ) ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` dataFrame = spark.read\ .orc("s3://s3path") ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die Operation [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.sql.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( connectionType="s3", format="orc", options=JsonOptions("""{"paths": ["s3://s3path"]}""") ).getDynamicFrame() } } ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` val dataFrame = spark.read .orc("s3://s3path") ``` ------ ## Beispiel: Schreiben von ORC-Dateien und -Ordnern in S3 **Voraussetzungen:** Sie benötigen ein initialisiertes DataFrame (`dataFrame`) oder DynamicFrame (`dynamicFrame`). Sie benötigen auch Ihren erwarteten S3-Ausgabepfad, `s3path`. **Konfiguration:** Geben Sie in Ihren Funktionsoptionen `format="orc"` an. Verwenden Sie in Ihren Verbindungsoptionen die `paths`-Schlüssel zum Angeben von `s3path`. Sie können die Art und Weise, wie der Writer mit S3 in `connection_options` interagiert, weiter verändern. Einzelheiten finden Sie unter Datenformatoptionen für ETL-Eingaben und -Ausgaben in AWS Glue:[Referenz zur Amazon-S3-Verbindungsoption](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Das folgende Code-Beispiel veranschaulicht den Prozess: ------ #### [ Python ] Verwenden Sie für dieses Beispiel die Methode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", format="orc", connection_options={ "path": "s3://s3path" } ) ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` df.write.orc("s3://s3path/") ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getSinkWithFormat-Methode](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="orc" ).writeDynamicFrame(dynamicFrame) } } ``` Sie können es auch DataFrames in einem Skript (`pyspark.sql.DataFrame`) verwenden. ``` df.write.orc("s3://s3path/") ``` ------ ## ORC-Konfigurationsreferenz Es gibt keine `format_options`-Werte für `format="orc"`. Es können jedoch alle Optionen, die vom zugrunde liegenden SparkSQL-Code akzeptiert werden, im Rahmen des `connection_options`-Map-Parameters übergeben werden. # Verwendung von Data-Lake-Frameworks mit AWS Glue ETL-Jobs Open-Source-Data-Lake-Frameworks vereinfachen die inkrementelle Datenverarbeitung für Dateien, die Sie in Data Lakes speichern, die auf Amazon S3 basieren. AWS Glue 3.0 und höher unterstützt die folgenden Open-Source-Data-Lake-Frameworks: + Apache Hudi + Linux Foundation Delta Lake + Apache Iceberg Wir bieten native Unterstützung für diese Frameworks an, sodass Sie Daten, die Sie in Amazon S3 speichern, transaktionskonsistent lesen und schreiben können. Es ist nicht erforderlich, einen separaten Konnektor zu installieren oder zusätzliche Konfigurationsschritte durchzuführen, um diese Frameworks in AWS Glue -ETL-Aufträgen zu verwenden. Wenn Sie Datensätze über die verwalten AWS Glue Data Catalog, können Sie AWS Glue Methoden zum Lesen und Schreiben von Data-Lake-Tabellen mit Spark verwenden. DataFrames Sie können Amazon S3 S3-Daten auch mithilfe der DataFrame Spark-API lesen und schreiben. In diesem Video erfahren Sie mehr über die Grundlagen der Funktionsweise von Apache Hudi, Apache Iceberg und Delta Lake. Sie erfahren, wie Sie Daten in Ihren Data Lake einfügen, aktualisieren und löschen und wie jedes dieser Frameworks funktioniert. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/fryfx0Zg7KA/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/fryfx0Zg7KA) **Topics** + [Einschränkungen](aws-glue-programming-etl-datalake-native-frameworks-limitations.md) + [Verwenden des Hudi-Frameworks in Glue AWS](aws-glue-programming-etl-format-hudi.md) + [Verwenden des Delta Lake-Frameworks in AWS Glue](aws-glue-programming-etl-format-delta-lake.md) + [Das Iceberg-Framework in AWS Glue verwenden](aws-glue-programming-etl-format-iceberg.md) # Einschränkungen Beachten Sie die folgenden Einschränkungen, bevor Sie Data Lake-Frameworks mit verwenden. AWS Glue + Die folgenden AWS Glue `GlueContext` Methoden für unterstützen das Lesen und Schreiben von Data Lake-Framework-Tabellen DynamicFrame nicht. Verwenden Sie stattdessen die `GlueContext` Methoden für DataFrame oder die DataFrame Spark-API. + `create_dynamic_frame.from_catalog` + `write_dynamic_frame.from_catalog` + `getDynamicFrame` + `writeDynamicFrame` + Die folgenden `GlueContext` Methoden für DataFrame werden von Lake Formation Permission Control unterstützt: + `create_data_frame.from_catalog` + `write_data_frame.from_catalog` + `getDataFrame` + `writeDataFrame` + Das [Gruppieren kleiner Dateien](grouping-input-files.md) wird nicht unterstützt. + [Auftragslesezeichen](monitor-continuations.md) werden nicht unterstützt. + Apache Hudi 0.10.1 für AWS Glue 3.0 unterstützt keine Hudi Merge on Read (MoR) -Tabellen. + `ALTER TABLE … RENAME TO`ist für Apache Iceberg 0.13.1 für 3.0 nicht verfügbar. AWS Glue ## Einschränkungen für Tabellen im Data-Lake-Format, die mit Lake-Formation-Berechtigungen verwaltet werden Die Data-Lake-Formate sind über Lake Formation Formation-Berechtigungen in AWS Glue ETL integriert. Das Erstellen einer DynamicFrame Verwendung `create_dynamic_frame` wird nicht unterstützt. Weitere Informationen finden Sie in den folgenden Beispielen: + [Beispiel: Lesen und Schreiben einer Iceberg-Tabelle mit Lake-Formation-Berechtigungskontrolle](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-iceberg.html#aws-glue-programming-etl-format-iceberg-read-write-lake-formation-tables) + [Beispiel: Lesen und Schreiben einer Hudi-Tabelle mit Lake-Formation-Berechtigungskontrolle](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-hudi.html#aws-glue-programming-etl-format-hudi-read-write-lake-formation-tables) + [Beispiel: Lesen und Schreiben einer Delta-Lake-Tabelle mit Lake-Formation-Berechtigungskontrolle](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-delta-lake.html#aws-glue-programming-etl-format-delta-lake-read-write-lake-formation-tables) **Anmerkung** Die Integration mit AWS Glue ETL über Lake Formation Formation-Berechtigungen für Apache Hudi, Apache Iceberg und Delta Lake wird nur in AWS Glue Version 4.0 unterstützt. Apache Iceberg bietet die beste Integration mit AWS Glue ETL über Lake Formation Formation-Berechtigungen. Es unterstützt fast alle Operationen und beinhaltet SQL-Unterstützung. Hudi unterstützt die meisten grundlegenden Operationen mit Ausnahme von Verwaltungsoperationen. Dies liegt daran, dass diese Optionen im Allgemeinen durch das Schreiben von DataFrames erfolgen und über `additional_options` spezifiziert werden. Sie müssen AWS Glue APIs to create DataFrames für Ihre Operationen verwenden, da SparkSQL nicht unterstützt wird. Delta Lake unterstützt nur das Lesen, Anhängen und Überschreiben von Tabellendaten. Delta Lake erfordert die Verwendung eigener Bibliotheken, um verschiedene Aufgaben wie Aktualisierungen ausführen zu können. Die folgenden Funktionen sind für Iceberg-Tabellen, die mit Lake-Formation-Berechtigungen verwaltet werden, nicht verfügbar. + Verdichtung mit ETL AWS Glue + Spark SQL-Unterstützung über AWS Glue ETL Im Folgenden sind die Einschränkungen von Hudi-Tabellen aufgeführt, die mit Lake-Formation-Berechtigungen verwaltet werden: + Entfernen verwaister Dateien Im Folgenden sind die Einschränkungen von Delta-Lake-Tabellen aufgeführt, die mit Lake-Formation-Berechtigungen verwaltet werden: + Alle Features außer dem Einfügen und Lesen von Delta-Lake-Tabellen. # Verwenden des Hudi-Frameworks in Glue AWS AWS Glue 3.0 und höher unterstützt das Apache Hudi-Framework für Data Lakes. Hudi ist ein Open-Source-Framework für Data-Lake-Speicher, das die inkrementelle Datenverarbeitung und die Entwicklung von Datenpipelines vereinfacht. Dieses Thema behandelt verfügbare Funktionen für die Verwendung Ihrer Daten in AWS Glue, wenn Sie Ihre Daten in einer Hudi-Tabelle transportieren oder speichern. Weitere Informationen zu Hudi finden Sie in der offiziellen [Apache-Hudi-Dokumentation](https://hudi.apache.org/docs/overview/). Sie können AWS Glue verwenden, um Lese- und Schreibvorgänge an Hudi-Tabellen in Amazon S3 durchzuführen, oder mithilfe des AWS Glue-Datenkatalogs mit Hudi-Tabellen arbeiten. Zusätzliche Vorgänge wie Einfügen, Aktualisieren und alle [Apache-Spark-Vorgänge](https://hudi.apache.org/docs/quick-start-guide/) werden ebenfalls unterstützt. **Anmerkung** [Die Apache Hudi 0.15.0-Implementierung in AWS Glue 5.0 macht HUDI-7001 intern rückgängig.](https://github.com/apache/hudi/pull/9936) Es tritt keine Regression im Zusammenhang mit der komplexen Schlüsselgenerierung auf, wenn der Datensatzschlüssel aus einem einzigen Feld besteht. Dieses Verhalten unterscheidet sich jedoch von OSS Apache Hudi 0.15.0. Apache Hudi 0.10.1 für AWS Glue 3.0 unterstützt keine Hudi Merge on Read (MoR) -Tabellen. In der folgenden Tabelle ist die Hudi-Version aufgeführt, die in jeder AWS Glue-Version enthalten ist. **** | AWS Ausführung mit Glue | Unterstützte Hudi-Versionen | | --- | --- | | 5.1 | 1.0.2 | | 5.0 | 0.15.0 | | 4,0 | 0.12.1 | | 3.0 | 0.10.1 | Weitere Informationen zu den von AWS Glue unterstützten Data Lake-Frameworks finden Sie unter[Verwendung von Data-Lake-Frameworks mit AWS Glue ETL-Jobs](aws-glue-programming-etl-datalake-native-frameworks.md). ## Aktivieren von Hudi Führen Sie die folgenden Aufgaben aus, um Hudi for AWS Glue zu aktivieren: + Geben Sie `hudi` als Wert für den Auftragsparameter `--datalake-formats` an. Weitere Informationen finden Sie unter [Verwenden von Auftragsparametern in AWS Glue-Jobs](aws-glue-programming-etl-glue-arguments.md). + Erstellen Sie einen Schlüssel, der `--conf` nach Ihrem AWS Glue-Job benannt ist, und setzen Sie ihn auf den folgenden Wert. Alternativ können Sie die folgende Konfiguration mit `SparkConf` in Ihrem Skript festlegen. Diese Einstellungen helfen Apache Spark bei der korrekten Handhabung von Hudi-Tabellen. ``` spark.serializer=org.apache.spark.serializer.KryoSerializer ``` + Die Unterstützung Lake Formation Formation-Berechtigungen für Hudi ist standardmäßig für AWS Glue 4.0 aktiviert. Für zwei von Lake Formation registrierte reading/writing Hudi-Tabellen ist keine zusätzliche Konfiguration erforderlich. Um eine registrierte Hudi-Tabelle lesen zu können, muss die IAM-Rolle des AWS Glue-Jobs über die SELECT-Berechtigung verfügen. Um in eine registrierte Hudi-Tabelle zu schreiben, muss die IAM-Rolle des AWS Glue-Jobs über die SUPER-Berechtigung verfügen. Weitere Informationen zur Verwaltung von Lake-Formation-Berechtigungen finden Sie unter [Granting and revoking permissions on Data Catalog resources](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html). **Verwenden einer anderen Hudi-Version** Um eine Version von Hudi zu verwenden, die AWS Glue nicht unterstützt, geben Sie Ihre eigenen Hudi-JAR-Dateien mit dem `--extra-jars` Job-Parameter an. Schließen Sie `hudi` nicht als Wert für den Auftragsparameter `--datalake-formats` ein. Wenn Sie AWS Glue 5.0 oder höher verwenden, müssen Sie den `--user-jars-first true` Job-Parameter festlegen. ## Beispiel: Schreiben Sie eine Hudi-Tabelle in Amazon S3 und registrieren Sie sie im AWS Glue-Datenkatalog Dieses Beispielskript zeigt, wie eine Hudi-Tabelle in Amazon S3 geschrieben und die Tabelle im AWS Glue-Datenkatalog registriert wird. Das Beispiel verwendet das [Hive-Sync-Tool](https://hudi.apache.org/docs/syncing_metastore/) von Hudi zum Registrieren der Tabelle. **Anmerkung** In diesem Beispiel müssen Sie den `--enable-glue-datacatalog` Job-Parameter festlegen, um den AWS Glue-Datenkatalog als Apache Spark Hive-Metastore verwenden zu können. Weitere Informationen hierzu finden Sie unter [Verwenden von Auftragsparametern in AWS Glue-Jobs](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] ``` # Example: Create a Hudi table from a DataFrame # and register the table to Glue Data Catalog additional_options={ "hoodie.table.name": "", "hoodie.database.name": "", "hoodie.datasource.write.storage.type": "COPY_ON_WRITE", "hoodie.datasource.write.operation": "upsert", "hoodie.datasource.write.recordkey.field": "", "hoodie.datasource.write.precombine.field": "", "hoodie.datasource.write.partitionpath.field": "", "hoodie.datasource.write.hive_style_partitioning": "true", "hoodie.datasource.hive_sync.enable": "true", "hoodie.datasource.hive_sync.database": "", "hoodie.datasource.hive_sync.table": "", "hoodie.datasource.hive_sync.partition_fields": "", "hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc": "false", "hoodie.datasource.hive_sync.mode": "hms", "path": "s3://" } dataFrame.write.format("hudi") \ .options(**additional_options) \ .mode("overwrite") \ .save() ``` ------ #### [ Scala ] ``` // Example: Example: Create a Hudi table from a DataFrame // and register the table to Glue Data Catalog val additionalOptions = Map( "hoodie.table.name" -> "", "hoodie.database.name" -> "", "hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE", "hoodie.datasource.write.operation" -> "upsert", "hoodie.datasource.write.recordkey.field" -> "", "hoodie.datasource.write.precombine.field" -> "", "hoodie.datasource.write.partitionpath.field" -> "", "hoodie.datasource.write.hive_style_partitioning" -> "true", "hoodie.datasource.hive_sync.enable" -> "true", "hoodie.datasource.hive_sync.database" -> "", "hoodie.datasource.hive_sync.table" -> "", "hoodie.datasource.hive_sync.partition_fields" -> "", "hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc" -> "false", "hoodie.datasource.hive_sync.mode" -> "hms", "path" -> "s3://") dataFrame.write.format("hudi") .options(additionalOptions) .mode("append") .save() ``` ------ ## Beispiel: Lesen einer Hudi-Tabelle aus Amazon S3 mithilfe des AWS Glue-Datenkatalogs In diesem Beispiel wird die Hudi-Tabelle gelesen, die Sie in [Beispiel: Schreiben Sie eine Hudi-Tabelle in Amazon S3 und registrieren Sie sie im AWS Glue-Datenkatalog](#aws-glue-programming-etl-format-hudi-write) aus Amazon S3 erstellt haben. **Anmerkung** In diesem Beispiel müssen Sie den `--enable-glue-datacatalog` Job-Parameter festlegen, um den AWS Glue-Datenkatalog als Apache Spark Hive-Metastore verwenden zu können. Weitere Informationen hierzu finden Sie unter [Verwenden von Auftragsparametern in AWS Glue-Jobs](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Verwenden Sie für dieses Beispiel die `GlueContext.create\$1data\$1frame.from\$1catalog()`-Methode. ``` # Example: Read a Hudi table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) dataFrame = glueContext.create_data_frame.from_catalog( database = "", table_name = "" ) ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource)-Methode. ``` // Example: Read a Hudi table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dataFrame = glueContext.getCatalogSource( database = "", tableName = "" ).getDataFrame() } } ``` ------ ## Beispiel: Aktualisieren und Einfügen eines `DataFrame` in eine Hudi-Tabelle in Amazon S3 In diesem Beispiel wird der AWS Glue-Datenkatalog verwendet, um eine DataFrame in die Hudi-Tabelle einzufügen, in [Beispiel: Schreiben Sie eine Hudi-Tabelle in Amazon S3 und registrieren Sie sie im AWS Glue-Datenkatalog](#aws-glue-programming-etl-format-hudi-write) der Sie erstellt haben. **Anmerkung** In diesem Beispiel müssen Sie den `--enable-glue-datacatalog` Job-Parameter festlegen, um den AWS Glue-Datenkatalog als Apache Spark Hive-Metastore verwenden zu können. Weitere Informationen hierzu finden Sie unter [Verwenden von Auftragsparametern in AWS Glue-Jobs](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Verwenden Sie für dieses Beispiel die `GlueContext.write\$1data\$1frame.from\$1catalog()`-Methode. ``` # Example: Upsert a Hudi table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) glueContext.write_data_frame.from_catalog( frame = dataFrame, database = "", table_name = "", additional_options={ "hoodie.table.name": "", "hoodie.database.name": "", "hoodie.datasource.write.storage.type": "COPY_ON_WRITE", "hoodie.datasource.write.operation": "upsert", "hoodie.datasource.write.recordkey.field": "", "hoodie.datasource.write.precombine.field": "", "hoodie.datasource.write.partitionpath.field": "", "hoodie.datasource.write.hive_style_partitioning": "true", "hoodie.datasource.hive_sync.enable": "true", "hoodie.datasource.hive_sync.database": "", "hoodie.datasource.hive_sync.table": "", "hoodie.datasource.hive_sync.partition_fields": "", "hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc": "false", "hoodie.datasource.hive_sync.mode": "hms" } ) ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink)-Methode. ``` // Example: Upsert a Hudi table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import com.amazonaws.services.glue.util.JsonOptions import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getCatalogSink("", "", additionalOptions = JsonOptions(Map( "hoodie.table.name" -> "", "hoodie.database.name" -> "", "hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE", "hoodie.datasource.write.operation" -> "upsert", "hoodie.datasource.write.recordkey.field" -> "", "hoodie.datasource.write.precombine.field" -> "", "hoodie.datasource.write.partitionpath.field" -> "", "hoodie.datasource.write.hive_style_partitioning" -> "true", "hoodie.datasource.hive_sync.enable" -> "true", "hoodie.datasource.hive_sync.database" -> "", "hoodie.datasource.hive_sync.table" -> "", "hoodie.datasource.hive_sync.partition_fields" -> "", "hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc" -> "false", "hoodie.datasource.hive_sync.mode" -> "hms" ))) .writeDataFrame(dataFrame, glueContext) } } ``` ------ ## Beispiel: Lesen einer Hudi-Tabelle aus Amazon S3 mit Spark In diesem Beispiel wird mithilfe der DataFrame Spark-API eine Hudi-Tabelle aus Amazon S3 gelesen. ------ #### [ Python ] ``` # Example: Read a Hudi table from S3 using a Spark DataFrame dataFrame = spark.read.format("hudi").load("s3://") ``` ------ #### [ Scala ] ``` // Example: Read a Hudi table from S3 using a Spark DataFrame val dataFrame = spark.read.format("hudi").load("s3://") ``` ------ ## Beispiel: Schreiben einer Hudi-Tabelle in Amazon S3 mit Spark In diesem Beispiel wird eine Hudi-Tabelle mit Spark in Amazon S3 geschrieben. ------ #### [ Python ] ``` # Example: Write a Hudi table to S3 using a Spark DataFrame dataFrame.write.format("hudi") \ .options(**additional_options) \ .mode("overwrite") \ .save("s3://) ``` ------ #### [ Scala ] ``` // Example: Write a Hudi table to S3 using a Spark DataFrame dataFrame.write.format("hudi") .options(additionalOptions) .mode("overwrite") .save("s3://") ``` ------ ## Beispiel: Lesen und Schreiben einer Hudi-Tabelle mit Lake-Formation-Berechtigungskontrolle In diesem Beispiel wird mit Lake-Formation-Berechtigungen in einer Hudi-Tabelle gelesen und geschrieben. 1. Erstellen einer Hudi-Tabelle und Registrieren in Lake Formation. 1. Um die Lake-Formation-Berechtigungskontrolle zu aktivieren, müssen Sie zunächst den Amazon-S3-Tabellenpfad auf Lake Formation registrieren. Weitere Informationen finden Sie unter [Registrieren eines Amazon-S3-Speicherorts](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Sie können es entweder über die Lake Formation Formation-Konsole oder über die AWS CLI registrieren: ``` aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region ``` Sobald Sie einen Amazon S3 S3-Standort registriert haben, gibt jede AWS Glue-Tabelle, die auf den Standort (oder einen seiner untergeordneten Standorte) zeigt, den Wert für den `IsRegisteredWithLakeFormation` Parameter im `GetTable` Aufruf als wahr zurück. 1. Erstellen einer Hudi-Tabelle, die über die Spark-DataFrame-API auf den registrierten Amazon-S3-Pfad verweist: ``` hudi_options = { 'hoodie.table.name': table_name, 'hoodie.database.name': database_name, 'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE', 'hoodie.datasource.write.recordkey.field': 'product_id', 'hoodie.datasource.write.table.name': table_name, 'hoodie.datasource.write.operation': 'upsert', 'hoodie.datasource.write.precombine.field': 'updated_at', 'hoodie.datasource.write.hive_style_partitioning': 'true', 'hoodie.upsert.shuffle.parallelism': 2, 'hoodie.insert.shuffle.parallelism': 2, 'path': , 'hoodie.datasource.hive_sync.enable': 'true', 'hoodie.datasource.hive_sync.database': database_name, 'hoodie.datasource.hive_sync.table': table_name, 'hoodie.datasource.hive_sync.use_jdbc': 'false', 'hoodie.datasource.hive_sync.mode': 'hms' } df_products.write.format("hudi") \ .options(**hudi_options) \ .mode("overwrite") \ .save() ``` 1. Erteilen Sie Lake Formation die Erlaubnis für die IAM-Rolle AWS Glue Job. Sie können Berechtigungen entweder über die Lake Formation Formation-Konsole oder über die AWS CLI gewähren. Weitere Informationen finden Sie unter [Granting table permissions using the Lake Formation console and the named resource method](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html). 1. Lesen der in Lake Formation registrierten Hudi-Tabelle. Der Code entspricht dem Lesen einer nicht registrierten Hudi-Tabelle. Beachten Sie, dass die IAM-Rolle des AWS Glue-Jobs über die SELECT-Berechtigung verfügen muss, damit der Lesevorgang erfolgreich ist. ``` val dataFrame = glueContext.getCatalogSource( database = "", tableName = "" ).getDataFrame() ``` 1. Schreiben in eine in Lake Formation registrierte Hudi-Tabelle. Der Code entspricht dem Schreiben in eine nicht registrierte Hudi-Tabelle. Beachten Sie, dass die IAM-Rolle des AWS Glue-Jobs über die SUPER-Berechtigung verfügen muss, damit der Schreibvorgang erfolgreich ist. ``` glueContext.getCatalogSink("", "", additionalOptions = JsonOptions(Map( "hoodie.table.name" -> "", "hoodie.database.name" -> "", "hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE", "hoodie.datasource.write.operation" -> "", "hoodie.datasource.write.recordkey.field" -> "", "hoodie.datasource.write.precombine.field" -> "", "hoodie.datasource.write.partitionpath.field" -> "", "hoodie.datasource.write.hive_style_partitioning" -> "true", "hoodie.datasource.hive_sync.enable" -> "true", "hoodie.datasource.hive_sync.database" -> "", "hoodie.datasource.hive_sync.table" -> "", "hoodie.datasource.hive_sync.partition_fields" -> "", "hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc" -> "false", "hoodie.datasource.hive_sync.mode" -> "hms" ))) .writeDataFrame(dataFrame, glueContext) ``` # Verwenden des Delta Lake-Frameworks in AWS Glue AWS Glue 3.0 und höher unterstützt das Delta Lake-Framework der Linux Foundation. Delta Lake ist ein Open-Source-Framework für Data-Lake-Speicher, mit dem Sie ACID-Transaktionen durchführen, die Verarbeitung von Metadaten skalieren und Streaming- und Batch-Datenverarbeitung vereinheitlichen können. In diesem Thema werden verfügbare Funktionen für die Verwendung Ihrer Daten in AWS Glue beschrieben, wenn Sie Ihre Daten in einer Delta Lake-Tabelle transportieren oder speichern. Weitere Informationen zu Delta Lake finden Sie in der offiziellen [Delta-Lake-Dokumentation](https://docs.delta.io/latest/delta-intro.html). Sie können AWS Glue verwenden, um Lese- und Schreibvorgänge an Delta Lake-Tabellen in Amazon S3 durchzuführen, oder mit Delta Lake-Tabellen mithilfe des AWS Glue-Datenkatalogs arbeiten. Zusätzliche Operationen wie Einfügen, Aktualisieren und [Lesen und Schreiben von Tabellenbatches](https://docs.delta.io/0.7.0/api/python/index.html) werden ebenfalls unterstützt. Wenn Sie Delta-Lake-Tabellen verwenden, haben Sie auch die Möglichkeit, Methoden aus der Delta-Lake-Python-Bibliothek zu verwenden, wie z. B. `DeltaTable.forPath`. Weitere Informationen über die Python-Bibliothek von Delta Lake finden Sie in der Python-Dokumentation von Delta Lake. In der folgenden Tabelle sind die Versionen von Delta Lake aufgeführt, die in jeder AWS Glue-Version enthalten sind. **** | AWS Ausführung mit Glue | Unterstützte Delta-Lake-Version | | --- | --- | | 5.1 | 3.3.2 | | 5.0 | 3.3.0 | | 4,0 | 2.1.0 | | 3.0 | 1.0.0 | Weitere Informationen zu den von AWS Glue unterstützten Data Lake-Frameworks finden Sie unter[Verwendung von Data-Lake-Frameworks mit AWS Glue ETL-Jobs](aws-glue-programming-etl-datalake-native-frameworks.md). ## Delta Lake für AWS Glue aktivieren Führen Sie die folgenden Aufgaben aus, um Delta Lake für AWS Glue zu aktivieren: + Geben Sie `delta` als Wert für den Auftragsparameter `--datalake-formats` an. Weitere Informationen finden Sie unter [Verwenden von Auftragsparametern in AWS Glue-Jobs](aws-glue-programming-etl-glue-arguments.md). + Erstellen Sie einen Schlüssel, der `--conf` nach Ihrem AWS Glue-Job benannt ist, und setzen Sie ihn auf den folgenden Wert. Alternativ können Sie die folgende Konfiguration mit `SparkConf` in Ihrem Skript festlegen. Diese Einstellungen helfen Apache Spark bei der korrekten Handhabung von Delta-Lake-Tabellen. ``` spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension --conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog --conf spark.delta.logStore.class=org.apache.spark.sql.delta.storage.S3SingleDriverLogStore ``` + Die Unterstützung Lake Formation Formation-Berechtigungen für Delta-Tabellen ist standardmäßig für AWS Glue 4.0 aktiviert. Für zwei von Lake Formation registrierte reading/writing Delta-Tabellen ist keine zusätzliche Konfiguration erforderlich. Um eine registrierte Delta-Tabelle lesen zu können, muss die IAM-Rolle des AWS Glue-Jobs über die SELECT-Berechtigung verfügen. Um in eine registrierte Delta-Tabelle schreiben zu können, muss die IAM-Rolle des AWS Glue-Jobs über die SUPER-Berechtigung verfügen. Weitere Informationen zur Verwaltung von Lake-Formation-Berechtigungen finden Sie unter [Granting and revoking permissions on Data Catalog resources](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html). **Verwenden einer anderen Delta-Lake-Version** Um eine Version von Delta Lake zu verwenden, die AWS Glue nicht unterstützt, geben Sie Ihre eigenen Delta Lake-JAR-Dateien mit dem `--extra-jars` Job-Parameter an. Schließen Sie `delta` nicht als Wert für den Auftragsparameter `--datalake-formats` ein. Wenn Sie AWS Glue 5.0 oder höher verwenden, müssen Sie den `--user-jars-first true` Job-Parameter festlegen. Um die Delta-Lake-Python-Bibliothek in diesem Fall zu verwenden, müssen Sie die JAR-Dateien der Bibliothek mithilfe des `--extra-py-files`-Auftragsparameters angeben. Die Python-Bibliothek ist in den JAR-Dateien von Delta Lake enthalten. ## Beispiel: Schreiben Sie eine Delta Lake-Tabelle in Amazon S3 und registrieren Sie sie im AWS Glue Data Catalog Das folgende AWS Glue-ETL-Skript veranschaulicht, wie Sie eine Delta Lake-Tabelle in Amazon S3 schreiben und die Tabelle im AWS Glue-Datenkatalog registrieren. ------ #### [ Python ] ``` # Example: Create a Delta Lake table from a DataFrame # and register the table to Glue Data Catalog additional_options = { "path": "s3://" } dataFrame.write \ .format("delta") \ .options(**additional_options) \ .mode("append") \ .partitionBy("") \ .saveAsTable(".") ``` ------ #### [ Scala ] ``` // Example: Example: Create a Delta Lake table from a DataFrame // and register the table to Glue Data Catalog val additional_options = Map( "path" -> "s3://" ) dataFrame.write.format("delta") .options(additional_options) .mode("append") .partitionBy("") .saveAsTable(".") ``` ------ ## Beispiel: Lesen einer Delta Lake-Tabelle aus Amazon S3 mithilfe des AWS Glue-Datenkatalogs Das folgende AWS Glue-ETL-Skript liest die Delta Lake-Tabelle, in der Sie erstellt haben[Beispiel: Schreiben Sie eine Delta Lake-Tabelle in Amazon S3 und registrieren Sie sie im AWS Glue Data Catalog](#aws-glue-programming-etl-format-delta-lake-write). ------ #### [ Python ] Verwenden Sie für dieses Beispiel die [create\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog)-Methode. ``` # Example: Read a Delta Lake table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource)-Methode. ``` // Example: Read a Delta Lake table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val df = glueContext.getCatalogSource("", "", additionalOptions = additionalOptions) .getDataFrame() } } ``` ------ ## Beispiel: Fügen Sie a mithilfe des AWS Glue-Datenkatalogs `DataFrame` in eine Delta Lake-Tabelle in Amazon S3 ein In diesem Beispiel werden Daten in die Delta-Lake-Tabelle eingefügt, die Sie in [Beispiel: Schreiben Sie eine Delta Lake-Tabelle in Amazon S3 und registrieren Sie sie im AWS Glue Data Catalog](#aws-glue-programming-etl-format-delta-lake-write) erstellt haben. **Anmerkung** In diesem Beispiel müssen Sie den `--enable-glue-datacatalog` Job-Parameter festlegen, um den AWS Glue-Datenkatalog als Apache Spark Hive-Metastore verwenden zu können. Weitere Informationen hierzu finden Sie unter [Verwenden von Auftragsparametern in AWS Glue-Jobs](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Verwenden Sie für dieses Beispiel die [create\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog)-Methode. ``` # Example: Insert into a Delta Lake table in S3 using Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink)-Methode. ``` // Example: Insert into a Delta Lake table in S3 using Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getCatalogSink("", "", additionalOptions = additionalOptions) .writeDataFrame(dataFrame, glueContext) } } ``` ------ ## Beispiel: Lesen einer Delta-Lake-Tabelle aus Amazon S3 mit der Spark-API In diesem Beispiel wird mit der Spark-API eine Delta-Lake-Tabelle aus Amazon S3 gelesen. ------ #### [ Python ] ``` # Example: Read a Delta Lake table from S3 using a Spark DataFrame dataFrame = spark.read.format("delta").load("s3://") ``` ------ #### [ Scala ] ``` // Example: Read a Delta Lake table from S3 using a Spark DataFrame val dataFrame = spark.read.format("delta").load("s3://") ``` ------ ## Beispiel: Schreiben einer Delta-Lake-Tabelle in Amazon S3 mit Spark In diesem Beispiel wird eine Delta-Lake-Tabelle mit Spark in Amazon S3 geschrieben. ------ #### [ Python ] ``` # Example: Write a Delta Lake table to S3 using a Spark DataFrame dataFrame.write.format("delta") \ .options(**additional_options) \ .mode("overwrite") \ .partitionBy("") .save("s3://") ``` ------ #### [ Scala ] ``` // Example: Write a Delta Lake table to S3 using a Spark DataFrame dataFrame.write.format("delta") .options(additionalOptions) .mode("overwrite") .partitionBy("") .save("s3://") ``` ------ ## Beispiel: Lesen und Schreiben einer Delta-Lake-Tabelle mit Lake-Formation-Berechtigungskontrolle In diesem Beispiel wird mit Lake-Formation-Berechtigungen in einer Delta-Lake-Tabelle gelesen und geschrieben. 1. Erstellen einer Delta-Tabelle und Registrieren in Lake Formation 1. Um die Lake-Formation-Berechtigungskontrolle zu aktivieren, müssen Sie zunächst den Amazon-S3-Tabellenpfad auf Lake Formation registrieren. Weitere Informationen finden Sie unter [Registrieren eines Amazon-S3-Speicherorts](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Sie können es entweder über die Lake Formation Formation-Konsole oder über die AWS CLI registrieren: ``` aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region ``` Sobald Sie einen Amazon S3 S3-Standort registriert haben, gibt jede AWS Glue-Tabelle, die auf den Standort (oder einen seiner untergeordneten Standorte) zeigt, den Wert für den `IsRegisteredWithLakeFormation` Parameter im `GetTable` Aufruf als wahr zurück. 1. Erstellen einer Delta-Tabelle, die über Spark auf den registrierten Amazon-S3-Pfad verweist: **Anmerkung** Im Folgenden sind Python-Beispiele aufgeführt. ``` dataFrame.write \ .format("delta") \ .mode("overwrite") \ .partitionBy("") \ .save("s3://") ``` Nachdem die Daten in Amazon S3 geschrieben wurden, verwenden Sie den AWS Glue-Crawler, um eine neue Delta-Katalogtabelle zu erstellen. Weitere Informationen finden Sie unter [Einführung der nativen Delta Lake-Tabellenunterstützung mit AWS Glue-Crawlern](https://aws.amazon.com/blogs/big-data/introducing-native-delta-lake-table-support-with-aws-glue-crawlers/). Sie können die Tabelle auch manuell über die AWS `CreateTable` Glue-API erstellen. 1. Erteilen Sie Lake Formation die Erlaubnis für die IAM-Rolle des Jobs AWS Glue. Sie können Berechtigungen entweder über die Lake Formation Formation-Konsole oder über die AWS CLI gewähren. Weitere Informationen finden Sie unter [Granting table permissions using the Lake Formation console and the named resource method](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html). 1. Lesen der in Lake Formation registrierten Delta-Tabelle. Der Code entspricht dem Lesen einer nicht registrierten Delta-Tabelle. Beachten Sie, dass die IAM-Rolle des AWS Glue-Jobs über die SELECT-Berechtigung verfügen muss, damit der Lesevorgang erfolgreich ist. ``` # Example: Read a Delta Lake table from Glue Data Catalog df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` 1. Schreiben in eine in Lake Formation registrierte Delta-Tabelle. Der Code entspricht dem Schreiben in eine nicht registrierte Delta-Tabelle. Beachten Sie, dass die IAM-Rolle des AWS Glue-Jobs über die SUPER-Berechtigung verfügen muss, damit der Schreibvorgang erfolgreich ist. Standardmäßig verwendet AWS Glue den `Append` SaveMode. Sie können das ändern, indem Sie die saveMode-Option in `additional_options` einstellen. Informationen zur saveMode-Unterstützung in Delta-Tabellen finden Sie unter [Write to a table](https://docs.delta.io/latest/delta-batch.html#write-to-a-table). ``` glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` # Das Iceberg-Framework in AWS Glue verwenden AWS Glue 3.0 und höher unterstützt das Apache Iceberg-Framework für Data Lakes. Iceberg bietet ein leistungsstarkes Tabellenformat, das genauso wie eine SQL-Tabelle funktioniert. In diesem Thema werden verfügbare Funktionen für die Verwendung Ihrer Daten in AWS Glue beschrieben, wenn Sie Ihre Daten in einer Iceberg-Tabelle transportieren oder speichern. Weitere Informationen zu Iceberg finden Sie in der offiziellen [Apache-Iceberg-Dokumentation](https://iceberg.apache.org/docs/latest/). Sie können AWS Glue verwenden, um Lese- und Schreibvorgänge an Iceberg-Tabellen in Amazon S3 durchzuführen, oder mithilfe des AWS Glue-Datenkatalogs mit Iceberg-Tabellen arbeiten. Zusätzliche Vorgänge wie Einfügen/Aktualisieren und alle [Spark-Abfragen](https://iceberg.apache.org/docs/latest/spark-queries/) und [Spark-Schreibvorgänge](https://iceberg.apache.org/docs/latest/spark-writes/) werden ebenfalls unterstützt. Aktualisieren wird für Iceberg-Tabellen nicht unterstützt. **Anmerkung** `ALTER TABLE … RENAME TO` ist für Apache Iceberg 0.13.1 für AWS Glue 3.0 nicht verfügbar. In der folgenden Tabelle sind die Versionen von Iceberg aufgeführt, die in jeder AWS Glue-Version enthalten sind. **** | AWS Ausführung mit Glue | Unterstützte Iceberg-Version | | --- | --- | | 5.1 | 1.10.0 | | 5.0 | 1.7.1 | | 4,0 | 1.0.0 | | 3.0 | 0.13.1 | Weitere Informationen zu den von AWS Glue unterstützten Data Lake-Frameworks finden Sie unter[Verwendung von Data-Lake-Frameworks mit AWS Glue ETL-Jobs](aws-glue-programming-etl-datalake-native-frameworks.md). ## Aktivierung des Iceberg-Frameworks Gehen Sie wie folgt vor, um Iceberg for AWS Glue zu aktivieren: + Geben Sie `iceberg` als Wert für den Auftragsparameter `--datalake-formats` an. Weitere Informationen finden Sie unter [Verwenden von Auftragsparametern in AWS Glue-Jobs](aws-glue-programming-etl-glue-arguments.md). + Erstellen Sie einen Schlüssel, der `--conf` nach Ihrem AWS Glue-Job benannt ist, und setzen Sie ihn auf den folgenden Wert. Alternativ können Sie die folgende Konfiguration mit `SparkConf` in Ihrem Skript festlegen. Diese Einstellungen helfen Apache Spark bei der korrekten Handhabung von Iceberg-Tabellen. ``` spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions --conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog --conf spark.sql.catalog.glue_catalog.warehouse=s3:/// --conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog --conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO ``` Wenn Sie Iceberg-Tabellen lesen oder in sie schreiben, die bei Lake Formation registriert sind, folgen Sie den Anweisungen [Verwendung von AWS Glue mit AWS Lake Formation für eine feinkörnige Zugriffskontrolle](security-lf-enable.md) in AWS Glue 5.0 und höher. Fügen Sie in AWS Glue 4.0 die folgende Konfiguration hinzu, um die Lake Formation Formation-Unterstützung zu aktivieren. ``` --conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true --conf spark.sql.catalog.glue_catalog.glue.id= ``` Wenn Sie AWS Glue 3.0 mit Iceberg 0.13.1 verwenden, müssen Sie die folgenden zusätzlichen Konfigurationen festlegen, um den Amazon DynamoDB-Sperrmanager zu verwenden, um eine atomare Transaktion sicherzustellen. AWS Glue 4.0 oder höher verwendet standardmäßig optimistisches Sperren. Weitere Informationen finden Sie unter [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/#dynamodb-lock-manager) in der offiziellen Apache Iceberg-Dokumentation. ``` --conf spark.sql.catalog.glue_catalog.lock-impl=org.apache.iceberg.aws.glue.DynamoLockManager --conf spark.sql.catalog.glue_catalog.lock.table= ``` **Verwendung einer anderen Iceberg-Version** Um eine Version von Iceberg zu verwenden, die AWS Glue nicht unterstützt, geben Sie Ihre eigenen Iceberg-JAR-Dateien mit dem `--extra-jars` Job-Parameter an. Schließen Sie `iceberg` nicht als Wert für den Auftragsparameter `--datalake-formats` ein. Wenn Sie AWS Glue 5.0 oder höher verwenden, müssen Sie den `--user-jars-first true` Job-Parameter festlegen. **Aktivierung der Verschlüsselung für Iceberg-Tabellen** **Anmerkung** Iceberg-Tabellen verfügen über eigene Mechanismen, um eine serverseitige Verschlüsselung zu ermöglichen. Sie sollten diese Konfiguration zusätzlich zur Sicherheitskonfiguration von AWS Glue aktivieren. Um die serverseitige Verschlüsselung für Iceberg-Tabellen zu aktivieren, lesen Sie die Anleitung in der [Iceberg-Dokumentation](https://iceberg.apache.org/docs/latest/aws/#s3-server-side-encryption). **Spark-Konfiguration für Iceberg regionsübergreifend hinzufügen** Um eine zusätzliche Spark-Konfiguration für den regionsübergreifenden Tabellenzugriff auf Iceberg mit dem AWS Glue-Datenkatalog hinzuzufügen AWS Lake Formation, gehen Sie wie folgt vor: 1. Erstellen Sie einen [Zugangspunkt für mehrere Regionen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/multi-region-access-point-create-examples.html). 1. Legen Sie die folgenden Spark-Eigenschaften fest: ``` ----- --conf spark.sql.catalog.my_catalog.s3.use-arn-region-enabled=true \ --conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket1", "arn:aws:s3:::accesspoint/.mrap \ --conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket2", "arn:aws:s3:::accesspoint/.mrap ----- ``` ## Beispiel: Schreiben Sie eine Iceberg-Tabelle in Amazon S3 und registrieren Sie sie im AWS Glue-Datenkatalog Dieses Beispielskript zeigt, wie eine Iceberg-Tabelle in Amazon S3 geschrieben wird. Das Beispiel verwendet [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/), um die Tabelle im AWS Glue-Datenkatalog zu registrieren. ------ #### [ Python ] ``` # Example: Create an Iceberg table from a DataFrame # and register the table to Glue Data Catalog dataFrame.createOrReplaceTempView("tmp_") query = f""" CREATE TABLE glue_catalog.. USING iceberg TBLPROPERTIES ("format-version"="2") AS SELECT * FROM tmp_ """ spark.sql(query) ``` ------ #### [ Scala ] ``` // Example: Example: Create an Iceberg table from a DataFrame // and register the table to Glue Data Catalog dataFrame.createOrReplaceTempView("tmp_") val query = """CREATE TABLE glue_catalog.. USING iceberg TBLPROPERTIES ("format-version"="2") AS SELECT * FROM tmp_ """ spark.sql(query) ``` ------ Alternativ können Sie mithilfe von Spark-Methoden eine Iceberg-Tabelle in Amazon S3 und den Data Catalog schreiben. Voraussetzungen: Sie müssen einen Katalog für die Nutzung durch die Iceberg-Bibliothek bereitstellen. Wenn Sie den AWS Glue-Datenkatalog verwenden, macht AWS Glue dies einfach. Der AWS Glue-Datenkatalog ist für die Verwendung durch die Spark-Bibliotheken vorkonfiguriert als`glue_catalog`. Datenkatalogtabellen sind mit a *databaseName* und a *tableName* gekennzeichnet. Weitere Informationen zum AWS Glue-Datenkatalog finden Sie unter[Datenermittlung und Katalogisierung in AWS Glue](catalog-and-crawler.md). Wenn Sie den AWS Glue-Datenkatalog nicht verwenden, müssen Sie einen Katalog über Spark bereitstellen APIs. Weitere Informationen finden Sie unter [Spark-Konfiguration](https://iceberg.apache.org/docs/latest/spark-configuration/) in der Iceberg-Dokumentation. In diesem Beispiel wird mithilfe von Spark eine Iceberg-Tabelle in Amazon S3 und den Data Catalog geschrieben. ------ #### [ Python ] ``` # Example: Write an Iceberg table to S3 on the Glue Data Catalog # Create (equivalent to CREATE TABLE AS SELECT) dataFrame.writeTo("glue_catalog.databaseName.tableName") \ .tableProperty("format-version", "2") \ .create() # Append (equivalent to INSERT INTO) dataFrame.writeTo("glue_catalog.databaseName.tableName") \ .tableProperty("format-version", "2") \ .append() ``` ------ #### [ Scala ] ``` // Example: Write an Iceberg table to S3 on the Glue Data Catalog // Create (equivalent to CREATE TABLE AS SELECT) dataFrame.writeTo("glue_catalog.databaseName.tableName") .tableProperty("format-version", "2") .create() // Append (equivalent to INSERT INTO) dataFrame.writeTo("glue_catalog.databaseName.tableName") .tableProperty("format-version", "2") .append() ``` ------ ## Beispiel: Eine Iceberg-Tabelle aus Amazon S3 mithilfe des AWS Glue-Datenkatalogs lesen In diesem Beispiel wird die Iceberg-Tabelle gelesen, die Sie in [Beispiel: Schreiben Sie eine Iceberg-Tabelle in Amazon S3 und registrieren Sie sie im AWS Glue-Datenkatalog](#aws-glue-programming-etl-format-iceberg-write) erstellt haben. ------ #### [ Python ] Verwenden Sie für dieses Beispiel die `GlueContext.create\$1data\$1frame.from\$1catalog()`-Methode. ``` # Example: Read an Iceberg table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource)-Methode. ``` // Example: Read an Iceberg table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val df = glueContext.getCatalogSource("", "", additionalOptions = additionalOptions) .getDataFrame() } } ``` ------ ## Beispiel: Fügen Sie a mithilfe des AWS Glue-Datenkatalogs `DataFrame` in eine Iceberg-Tabelle in Amazon S3 ein In diesem Beispiel werden Daten in die Iceberg-Tabelle eingefügt, die Sie in [Beispiel: Schreiben Sie eine Iceberg-Tabelle in Amazon S3 und registrieren Sie sie im AWS Glue-Datenkatalog](#aws-glue-programming-etl-format-iceberg-write) erstellt haben. **Anmerkung** In diesem Beispiel müssen Sie den `--enable-glue-datacatalog` Job-Parameter festlegen, um den AWS Glue-Datenkatalog als Apache Spark Hive-Metastore verwenden zu können. Weitere Informationen hierzu finden Sie unter [Verwenden von Auftragsparametern in AWS Glue-Jobs](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Verwenden Sie für dieses Beispiel die `GlueContext.write\$1data\$1frame.from\$1catalog()`-Methode. ``` # Example: Insert into an Iceberg table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Verwenden Sie für dieses Beispiel die [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink)-Methode. ``` // Example: Insert into an Iceberg table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getCatalogSink("", "", additionalOptions = additionalOptions) .writeDataFrame(dataFrame, glueContext) } } ``` ------ ## Beispiel: Lesen einer Iceberg-Tabelle aus Amazon S3 mit Spark Voraussetzungen: Sie müssen einen Katalog für die Nutzung durch die Iceberg-Bibliothek bereitstellen. Wenn Sie den AWS Glue-Datenkatalog verwenden, macht AWS Glue dies einfach. Der AWS Glue-Datenkatalog ist für die Verwendung durch die Spark-Bibliotheken vorkonfiguriert als`glue_catalog`. Datenkatalogtabellen sind mit a *databaseName* und a *tableName* gekennzeichnet. Weitere Informationen zum AWS Glue-Datenkatalog finden Sie unter[Datenermittlung und Katalogisierung in AWS Glue](catalog-and-crawler.md). Wenn Sie den AWS Glue-Datenkatalog nicht verwenden, müssen Sie einen Katalog über Spark bereitstellen APIs. Weitere Informationen finden Sie unter [Spark-Konfiguration](https://iceberg.apache.org/docs/latest/spark-configuration/) in der Iceberg-Dokumentation. In diesem Beispiel wird mithilfe von Spark eine Iceberg-Tabelle in Amazon S3 aus dem Data Catalog gelesen. ------ #### [ Python ] ``` # Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName") ``` ------ #### [ Scala ] ``` // Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog val dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName") ``` ------ ## Beispiel: Lesen und Schreiben einer Iceberg-Tabelle mit Lake-Formation-Berechtigungskontrolle In diesem Beispiel wird mit Lake-Formation-Berechtigungen in einer Iceberg-Tabelle gelesen und geschrieben. **Anmerkung** Dieses Beispiel funktioniert nur in AWS Glue 4.0. Folgen AWS Sie in Glue 5.0 und höher den Anweisungen unter[Verwendung von AWS Glue mit AWS Lake Formation für eine feinkörnige Zugriffskontrolle](security-lf-enable.md). 1. Erstellen einer Iceberg-Tabelle und Registrieren in Lake Formation. 1. Um die Lake-Formation-Berechtigungskontrolle zu aktivieren, müssen Sie zunächst den Amazon-S3-Tabellenpfad auf Lake Formation registrieren. Weitere Informationen finden Sie unter [Registrieren eines Amazon-S3-Speicherorts](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Sie können es entweder über die Lake Formation Formation-Konsole oder über die AWS CLI registrieren: ``` aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region ``` Sobald Sie einen Amazon S3 S3-Standort registriert haben, gibt jede AWS Glue-Tabelle, die auf den Standort (oder einen seiner untergeordneten Standorte) zeigt, den Wert für den `IsRegisteredWithLakeFormation` Parameter im `GetTable` Aufruf als wahr zurück. 1. Erstellen einer Iceberg-Tabelle, die über Spark SQL auf den registrierten Pfad verweist: **Anmerkung** Im Folgenden sind Python-Beispiele aufgeführt. ``` dataFrame.createOrReplaceTempView("tmp_") query = f""" CREATE TABLE glue_catalog.. USING iceberg AS SELECT * FROM tmp_ """ spark.sql(query) ``` Sie können die Tabelle auch manuell über die AWS `CreateTable` Glue-API erstellen. Weitere Informationen finden Sie unter [Creating Apache Iceberg tables](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-iceberg-tables.html). **Anmerkung** Die `UpdateTable`-API unterstützt derzeit nicht das Iceberg-Tabellenformat als Eingabe für den Vorgang. 1. Erteilen Sie Lake Formation die Berechtigung für die IAM-Rolle. Sie können Berechtigungen entweder über die Lake Formation Formation-Konsole oder über die AWS CLI gewähren. Weitere Informationen finden Sie unter: https://docs.aws.amazon.com/lake-formation/ latest/dg/granting -table-permissions.html 1. Lesen einer Iceberg-Tabelle, die bei Lake Formation registriert ist. Der Code entspricht dem Lesen einer nicht registrierten Iceberg-Tabelle. Beachten Sie, dass Ihre AWS Glue-Job-IAM-Rolle über die SELECT-Berechtigung verfügen muss, damit der Lesevorgang erfolgreich ist. ``` # Example: Read an Iceberg table from the AWS Glue Data Catalog from awsglue.context import GlueContextfrom pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` 1. Schreiben in einer Iceberg-Tabelle, die bei Lake Formation registriert ist. Der Code entspricht dem Schreiben in eine nicht registrierte Iceberg-Tabelle. Beachten Sie, dass Ihre AWS Glue-Job-IAM-Rolle über die SUPER-Berechtigung verfügen muss, damit der Schreibvorgang erfolgreich ist. ``` glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` ## Freigegebene Konfigurationsreferenz Sie können die folgenden `format_options`-Werte mit jedem Formattyp verwenden. + `attachFilename` – Eine Zeichenfolge im entsprechenden Format, die als Spaltenname verwendet werden soll. Wenn Sie diese Option angeben, wird der Name der Quelldatei für den Datensatz an den Datensatz angefügt. Der Parameterwert wird als Spaltenname verwendet. + `attachTimestamp` – Eine Zeichenfolge im entsprechenden Format, die als Spaltenname verwendet werden soll. Wenn Sie diese Option angeben, wird die Änderungszeit der Quelldatei für den Datensatz an den Datensatz angefügt. Der Parameterwert wird als Spaltenname verwendet.