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.
# 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.
[](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
)
```