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.
# Einen Cluster mit Iceberg verwenden
Dieser Abschnitt enthält Informationen zur Verwendung von Iceberg mit Spark, Trino, Flink und Hive.
# Verwenden Sie einen Iceberg-Cluster mit Spark
Ab Amazon-EMR-Version 6.5.0 können Sie Iceberg mit Ihrem Spark-Cluster verwenden, ohne dass Bootstrap-Aktionen erforderlich sind. Für Amazon-EMR-Versionen 6.4.0 und früher können Sie eine Bootstrap-Aktion verwenden, um alle erforderlichen Abhängigkeiten vorab zu installieren.
In diesem Tutorial verwenden Sie den, AWS CLI um mit Iceberg auf einem Amazon EMR Spark-Cluster zu arbeiten. Um die Konsole zur Erstellung eines Clusters mit Iceberg zu verwenden, folgen Sie den Schritten unter [Ein Data Lake von Apache Iceberg mit Amazon Athena, Amazon EMR und AWS Glue erstellen](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Erstellen Sie einen Iceberg-Cluster
Sie können einen Cluster mit installiertem Iceberg mithilfe der AWS-Managementkonsole, der AWS CLI oder der Amazon EMR-API erstellen. In diesem Tutorial verwenden Sie den, AWS CLI um mit Iceberg auf einem Amazon EMR-Cluster zu arbeiten. Um die Konsole zur Erstellung eines Clusters mit Iceberg zu verwenden, folgen Sie den Schritten unter [Ein Data Lake von Apache Iceberg mit Amazon Athena, Amazon EMR und AWS Glue erstellen](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Um Iceberg auf Amazon EMR mit dem zu verwenden AWS CLI, erstellen Sie zunächst einen Cluster mit den folgenden Schritten. Informationen zur Spezifizierung der Iceberg-Klassifizierung mithilfe von finden Sie unter oder AWS CLI. [Geben Sie AWS CLI beim Erstellen eines Clusters eine Konfiguration an, indem Sie](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Beim Erstellen eines Clusters eine Konfiguration mit dem Java SDK angeben](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk)
1. Erstellen Sie eine Datei `configurations.json`, mit folgendem Inhalt:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
1. Im nächsten Schritt erstellen Sie einen Cluster mit der folgenden Konfiguration. Ersetzen Sie den Amazon-S3-Beispiel-Bucket-Pfad und die Subnetz-ID durch Ihre eigene.
```
aws emr create-cluster --release-label emr-6.5.0 \
--applications Name=Spark \
--configurations file://configurations.json \
--region us-east-1 \
--name My_Spark_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole_V2 \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef0
```
Alternativ können Sie einen Amazon-EMR-Cluster mit der Spark-Anwendung erstellen und die Datei `/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` als JAR-Abhängigkeit in einen Spark-Auftrag aufnehmen. Weitere Informationen finden Sie unter [Anwendungen einreichen](https://spark.apache.org/docs/latest/submitting-applications.html#submitting-applications).
Um das JAR als Abhängigkeit in einen Spark-Auftrag aufzunehmen, fügen Sie der Spark-Anwendung die folgende Konfigurationseigenschaft hinzu:
```
--conf "spark.jars=/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar"
```
Weitere Informationen zu den Abhängigkeiten von Spark-Aufträgen finden Sie unter [Abhängigkeitsverwaltung](https://spark.apache.org/docs/latest/running-on-kubernetes.html#dependency-management) im Apache-Spark-Dokument [Ausführen von Spark in Kubernetes](https://spark.apache.org/docs/latest/running-on-kubernetes.html).
## Initialisieren Sie eine Spark-Sitzung für Iceberg
In den folgenden Beispielen wird veranschaulicht, wie Sie die interaktive Spark-Shell starten und die Spark-Übermittlung und Amazon EMR Notebooks verwenden, um mit Iceberg in Amazon EMR zu arbeiten.
------
#### [ spark-shell ]
1. Verbinden mit dem Master-Knoten über SSH. Weitere Informationen finden Sie unter [Mit SSH eine Verbindung zum Hauptknoten herstellen](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) im *Verwaltungshandbuch für Amazon EMR*.
1. Geben Sie den folgenden Befehl ein, um die Spark-Shell zu starten. Um die PySpark Shell zu verwenden, ersetzen Sie `spark-shell` durch`pyspark`.
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket/prefix/
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ spark-submit ]
1. Verbinden mit dem Master-Knoten über SSH. Weitere Informationen finden Sie unter [Mit SSH eine Verbindung zum Hauptknoten herstellen](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) im *Verwaltungshandbuch für Amazon EMR*.
1. Geben Sie den folgenden Befehl ein, um die Spark-Sitzung für Iceberg zu.starten.
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ EMR Studio notebooks ]
Um eine Spark-Sitzung mit EMR Studio-Notebooks zu initialisieren, konfigurieren Sie Ihre Spark-Sitzung mit dem `%%configure` magischen Befehl in Ihrem Amazon-EMR-Notebook, wie im folgenden Beispiel. Weitere Informationen finden Sie unter [Verwendung von EMR-Notebooks-Magics](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-magics.html#emr-magics) im *Verwaltungshandbuch für Amazon EMR*.
```
%%configure -f{
"conf":{
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
```
------
#### [ CLI ]
Führen Sie das folgende Beispiel aus, um einen Spark-Cluster mit der CLI zu initialisieren und alle Standardkonfigurationen der Spark Iceberg-Sitzung festzulegen. Weitere Informationen zur Angabe einer Konfigurationsklassifizierung mithilfe der AWS CLI Amazon EMR-API finden [Sie unter Anwendungen konfigurieren](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html).
```
[
{
"Classification": "spark-defaults",
"Properties": {
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
]
```
------
## Schreiben Sie an einen Iceberg-Tabelle
Das folgende Beispiel zeigt, wie ein Iceberg-Datensatz erstellt DataFrame und als Iceberg-Datensatz geschrieben wird. Die Beispiele in diesem Abschnitt veranschaulichen das Arbeiten mit Datensätzen unter Verwendung der Spark-Shell, während eine Verbindung mit dem Hauptknoten mittels SSH als Standard--Benutzer vorhanden ist.
**Anmerkung**
Um Codebeispiele in die Spark-Shell einzufügen, geben Sie an der Eingabeaufforderung `:paste` ein, fügen das Beispiel ein und drücken dann `CTRL+D`.
------
#### [ PySpark ]
Spark umfasst auch eine auf Python basierende Shell namens `pyspark`, mit der Sie Prototypen von in Python geschriebenen Spark-Programmen entwickeln können. Invoke wird in `pyspark` auf dem Hauptknoten festgelegt.
```
## Create a DataFrame.
data = spark.createDataFrame([
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
],["id", "creation_date", "last_update_time"])
## Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
#### [ Scala ]
```
import org.apache.spark.sql.SaveMode
import org.apache.spark.sql.functions._
// Create a DataFrame.
val data = Seq(
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
).toDF("id", "creation_date", "last_update_time")
// Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
## Lesen von einer Iceberg-Tabelle
------
#### [ PySpark ]
```
df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Scala ]
```
val df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Spark SQL ]
```
SELECT * from dev.db.iceberg_table LIMIT 10
```
------
## Verwenden des AWS Glue-Datenkatalogs mit Spark Iceberg
Sie können von Spark Iceberg aus eine Verbindung zum AWS Glue Data Catalog herstellen. Dieser Abschnitt zeigt verschiedene Befehle für die Verbindung.
### Connect zum AWS Standard-Glue-Katalog in Ihrer Standardregion her
Dieses Beispiel zeigt, wie mithilfe des Katalogtyps Glue eine Verbindung hergestellt wird. Wenn Sie keine Katalog-ID angeben, wird die Standardeinstellung verwendet:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
### Stellen Sie eine Connect zu einem AWS Glue-Katalog mit einer bestimmten Katalog-ID her
Dieses Beispiel zeigt, wie mithilfe einer Katalog-ID eine Verbindung hergestellt wird:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.catalog.my_catalog.glue.id=AWS Glue catalog ID \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Dieser Befehl kann verwendet werden, um eine Verbindung zu einem AWS Glue-Katalog in einem anderen Konto, zu einem RMS-Katalog oder zu einem Verbundkatalog herzustellen.
## Verwenden des Iceberg REST-Katalogs (IRC) mit Spark Iceberg
In den folgenden Abschnitten wird detailliert beschrieben, wie die Iceberg-Integration mit einem Katalog konfiguriert wird.
### Connect zum AWS IRC-Endpunkt von Glue Data Catalog her
Im Folgenden wird ein `spark-submit` Beispielbefehl für die Verwendung von Iceberg REST gezeigt:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=glue catalog ID \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=glue endpoint URI/iceberg \
--conf spark.sql.catalog.my_catalog.rest.sigv4-enabled=true \
--conf spark.sql.catalog.my_catalog.rest.signing-name=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Um ihn auf einem Cluster mit aktivierter Runtime-Role zu verwenden, sind die folgenden zusätzlichen Spark-Konfigurationseinstellungen erforderlich:
```
"spark.hadoop.fs.s3.credentialsResolverClass": "software.amazon.glue.GlueTableCredentialsResolver",
"spark.hadoop.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.hadoop.glue.id": glue catalog ID
"spark.hadoop.glue.endpoint": "glue endpoint"
```
Eine Liste der AWS Glue-Endpunkt-URLs für jede Region finden Sie unter [AWS Glue-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/glue.html).
### Stellen Sie eine Connect zu einem beliebigen IRC-Endpunkt her
Im Folgenden wird ein `spark-submit` Beispielbefehl für die Verwendung eines IRC-Endpunkts gezeigt:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=warehouse name \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=your rest endpoint \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
## Konfigurationsunterschiede bei der Verwendung von Iceberg versus SparkCatalog SparkSessionCatalog
Iceberg bietet zwei Möglichkeiten, Spark-Iceberg-Kataloge zu erstellen. Sie können die Spark-Konfiguration entweder auf oder `SparkCatalog` auf einstellen. `SparkSessionCatalog`
### Iceberg verwenden SparkCatalog
Im Folgenden wird der Befehl zur Verwendung **SparkCatalog**als Spark-Iceberg-Katalog gezeigt:
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog
```
Überlegungen zu diesem Ansatz:
+ Sie können auf Iceberg-Tabellen zugreifen, aber nicht auf andere Tabellen.
+ Der Katalogname darf nicht **spark\$1catalog** sein. Dies ist der Name des ersten Katalogs in Spark. Es stellt immer eine Verbindung zu einem Hive-Metastore her. Es ist der Standardkatalog in Spark, es sei denn, der Benutzer überschreibt ihn mit. `spark.sql.defaultCatalog`
+ Sie können den `spark.sql.defaultCatalog` auf Ihren Katalognamen setzen, um ihn zum Standardkatalog zu machen.
### Verwenden Sie Iceberg SparkSessionCatalog
Im Folgenden wird der Befehl zur Verwendung **SparkSessionCatalog**als Spark-Iceberg-Katalog gezeigt:
```
spark-shell \
--conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog \
--conf spark.sql.catalog.spark_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.spark_catalog.type=glue
```
Überlegungen zu diesem Ansatz:
+ Wenn eine Tabelle nicht als Iceberg-Tabelle gefunden wird, versucht Spark herauszufinden, ob es sich um eine Tabelle im Hive-Metastore handelt. Weitere Informationen finden Sie [unter Verwenden des AWS Glue-Datenkatalogs als Katalog für Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html).
+ Der Katalogname muss **spark\$1catalog** lauten.
## Verwenden von Iceberg Spark-Erweiterungen
Iceberg bietet eine Spark-Erweiterung an`org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions`, die Benutzer über die Spark-Erweiterungskonfiguration einrichten können. `spark.sql.extensions` Die Erweiterungen ermöglichen wichtige Iceberg-Funktionen wie DELETE, UPDATE und MERGE auf Zeilenebene, Iceberg-spezifische Spark-Datendefinitionssprachanweisungen und -prozeduren wie Komprimierung, Ablauf von Snapshots, Branching und Tagging usw. Weitere Informationen finden Sie im Folgenden:
+ Iceberg Spark-Schreiberweiterungen: [Spark](https://iceberg.apache.org/docs/nightly/spark-writes/) Writes
+ Iceberg Spark DDL-Erweiterungen: [ALTER TABLE](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/) SQL-Erweiterungen
+ [Iceberg Spark-Prozedurerweiterungen: Spark-Prozeduren](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/)
## Überlegungen zur Verwendung von Iceberg mit Spark
+ Amazon EMR 6.5.0 unterstützt Iceberg, das auf Amazon EMR auf EKS ausgeführt wird, standardmäßig nicht. Ein benutzerdefiniertes Amazon EMR 6.5.0-Image ist verfügbar, sodass Sie `--jars local:///usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` als `spark-submit`-Parameter übergeben können, um Iceberg-Tabellen auf Amazon EMR auf EKS zu erstellen. Weitere Informationen finden Sie unter [Einreichen eines Spark-Workloads in Amazon EMR mithilfe eines benutzerdefinierten Images](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-steps.html#docker-custom-images-submit) im *Entwicklerhandbuch zu Amazon EMR in EKS*. Sie können sich auch an Support wenden, um Unterstützung zu erhalten. Ab Amazon EMR 6.6.0 wird Iceberg auf Amazon EMR in EKS unterstützt.
+ Wenn Sie AWS Glue als Katalog für Iceberg verwenden, stellen Sie sicher, dass die Datenbank, in der Sie eine Tabelle erstellen, in AWS Glue vorhanden ist. Wenn Sie Dienste wie verwenden AWS Lake Formation und den Katalog nicht laden können, stellen Sie sicher, dass Sie über den richtigen Zugriff auf den Dienst verfügen, um den Befehl auszuführen.
+ Wenn Sie Iceberg verwenden SparkSessionCatalog, wie unter beschrieben[Konfigurationsunterschiede bei der Verwendung von Iceberg versus SparkCatalog SparkSessionCatalog](#emr-iceberg-spark-catalog), müssen Sie zusätzlich zur Konfiguration der Einstellungen des Spark Iceberg [AWS Glue-Datenkatalogs die unter AWS Glue-Datenkatalog konfigurieren als Apache Hive-Metastore](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html) beschriebenen Konfigurationsschritte befolgen.
# Verwenden Sie einen Iceberg-Cluster mit Trino
Ab Amazon-EMR-Version 6.6.0 können Sie Iceberg mit Ihrem Trino-Cluster verwenden.
In diesem Tutorial verwenden Sie den, AWS CLI um mit Iceberg auf einem Amazon EMR Trino-Cluster zu arbeiten. Um die Konsole zur Erstellung eines Clusters mit Iceberg zu verwenden, folgen Sie den Schritten unter [Ein Data Lake von Apache Iceberg mit Amazon Athena, Amazon EMR und AWS Glue erstellen](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Erstellen Sie einen Iceberg-Cluster
Um Iceberg auf Amazon EMR mit dem zu verwenden AWS CLI, erstellen Sie zunächst einen Cluster mit den folgenden Schritten. Informationen zur Spezifizierung der Iceberg-Klassifizierung mithilfe von finden Sie unter oder AWS CLI. [Geben Sie AWS CLI beim Erstellen eines Clusters eine Konfiguration an, indem Sie](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Beim Erstellen eines Clusters eine Konfiguration mit dem Java SDK angeben](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk)
1. Erstellen Sie eine `configurations.json` Datei mit dem folgenden Inhalt. Wenn Sie beispielsweise den Hive-Metastore als Ihren Katalog verwenden möchten, sollte Ihre Datei den folgenden Inhalt haben.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"hive.metastore.uri": "thrift://localhost:9083"
}
}
]
```
Wenn Sie den AWS Glue-Datenkatalog als Ihren Shop verwenden möchten, sollte Ihre Datei den folgenden Inhalt haben.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue"
}
}
]
```
Fügen Sie ab Amazon EMR 7.7.0 die Eigenschaft hinzu *fs.native-s3.enabled=true*
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue",
"fs.native-s3.enabled": "true"
}
}
]
```
1. Erstellen Sie einen Cluster mit der folgenden Konfiguration und ersetzen Sie den Beispielpfad und den Schlüsselnamen des Amazon S3 S3-Buckets durch Ihren eigenen.
```
aws emr create-cluster --release-label emr-6.7.0 \
--applications Name=Trino \
--region us-east-1 \
--name My_Trino_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket \
--configurations file://configurations.json \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=c3.4xlarge InstanceGroupType=CORE,InstanceCount=3,InstanceType=c3.4xlarge \
--use-default-roles \
--ec2-attributes KeyName=
```
## Initialisieren Sie eine Trino-Sitzung für Iceberg
Um eine Trino-Sitzung zu initialisieren, führen Sie den folgenden Befehl aus.
```
trino-cli --catalog iceberg
```
## Schreiben Sie an einen Iceberg-Tabelle
Erstellen Sie Ihre Tabelle und schreiben Sie in Ihre Tabelle mit den folgenden SQL-Befehlen.
```
trino> SHOW SCHEMAS;
trino> CREATE TABLE default.iceberg_table (
id int,
data varchar,
category varchar)
WITH (
format = 'PARQUET',
partitioning = ARRAY['category', 'bucket(id, 16)'],
location = 's3://amzn-s3-demo-bucket/')
trino> INSERT INTO default.iceberg_table VALUES (1,'a','c1'), (2,'b','c2'), (3,'c','c3');
```
## Lesen von Iceberg aus einer Tabelle
Um von Ihrer Iceberg-Tabelle zu lesen, führen Sie den folgenden Befehl aus.
```
trino> SELECT * from default.iceberg_table;
```
## Überlegungen zur Verwendung von Iceberg mit Trino
+ Amazon EMR 6.5 bietet keine native Trino-Iceberg-Catalog-Unterstützung für Iceberg. Trino benötigt Iceberg v0.11, daher empfehlen wir, einen Amazon-EMR-Cluster für Trino getrennt vom Spark-Cluster zu starten und Iceberg v0.11 auf diesem Cluster zu integrieren.
+ Wenn Sie AWS Glue als Katalog für Iceberg verwenden, stellen Sie sicher, dass die Datenbank, in der Sie eine Tabelle erstellen, in AWS Glue vorhanden ist. Wenn Sie Dienste wie verwenden AWS Lake Formation und den Katalog nicht laden können, stellen Sie sicher, dass Sie über den richtigen Zugriff auf den Dienst verfügen, um den Befehl auszuführen.
+ Die Iceberg Glue-Integration funktioniert nicht mit dem Redshift Managed Storage-Katalog.
# Verwenden Sie einen Iceberg-Cluster mit Flink
Ab Amazon-EMR-Version 6.9.0 können Sie Iceberg mit einem Flink-Cluster verwenden, ohne dass die Einrichtungsschritte erforderlich sind, die bei der Verwendung der Open-Source-Iceberg-Flink-Integration erforderlich sind.
## Erstellen Sie einen Iceberg-Cluster
Sie können einen Cluster mit installiertem Iceberg mithilfe der AWS-Managementkonsole, der AWS CLI oder der Amazon-EMR-API erstellen. In diesem Tutorial verwenden Sie den, AWS CLI um mit Iceberg auf einem Amazon EMR-Cluster zu arbeiten. Um die Konsole zur Erstellung eines Clusters mit Iceberg zu verwenden, folgen Sie den Schritten unter [Ein Data Lake von Apache Iceberg mit Amazon Athena, Amazon EMR und AWS Glue erstellen](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Um Iceberg auf Amazon EMR mit dem zu verwenden AWS CLI, erstellen Sie zunächst einen Cluster mit den folgenden Schritten. Informationen zur Spezifizierung der Iceberg-Klassifizierung mithilfe von finden Sie unter oder AWS CLI. [Geben Sie AWS CLI beim Erstellen eines Clusters eine Konfiguration an, indem Sie](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Beim Erstellen eines Clusters eine Konfiguration mit dem Java SDK angeben](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk) Erstellen Sie eine Datei mit dem Namen `configurations.json` und dem folgenden Inhalt:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
Erstellen Sie als Nächstes einen Cluster mit der folgenden Konfiguration und ersetzen Sie den Amazon-S3-Bucket-Beispielpfad und die Subnetz-ID durch Ihre eigenen Werte:
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Flink \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_flink_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Alternativ können Sie einen Amazon-EMR-6.9.0-Cluster mit einer Flink-Anwendung darin erstellen und die Datei `/usr/share/aws/iceberg/lib/iceberg-flink-runtime.jar` als JAR-Abhängigkeit in einem Flink-Auftrag verwenden.
## Verwenden des Flink-SQL-Clients
Das SQL-Client-Skript befindet sich unter `/usr/lib/flink/bin`. Sie können das Skript mit dem folgenden Befehl ausführen:
```
flink-yarn-session -d # starting the Flink YARN Session in detached mode
./sql-client.sh
```
Dadurch wird eine Flink-SQL-Shell gestartet.
## Flink-Beispiele
### Erstellen Sie eine Iceberg-Tabelle
**Flink SQL**
```
CREATE CATALOG glue_catalog WITH (
'type'='iceberg',
'warehouse'='',
'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',
'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'
);
USE CATALOG glue_catalog;
CREATE DATABASE IF NOT EXISTS ;
USE ;
CREATE TABLE IF NOT EXISTS `glue_catalog`.``.`sample` (id int, data string);
```
**Tabellen-API**
```
EnvironmentSettings settings =
EnvironmentSettings.newInstance().inBatchMode().build();
TableEnvironment tEnv = TableEnvironment.create(settings);
String warehouse = "";
String db = "";
tEnv.executeSql(
"CREATE CATALOG glue_catalog WITH (\n"
+ " 'type'='iceberg',\n"
+ " 'warehouse'='"
+ warehouse
+ "',\n"
+ " 'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',\n"
+ " 'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'\n"
+ " );");
tEnv.executeSql("USE CATALOG glue_catalog;");
tEnv.executeSql("CREATE DATABASE IF NOT EXISTS " + db + ";");
tEnv.executeSql("USE " + db + ";");
tEnv.executeSql(
"CREATE TABLE `glue_catalog`.`" + db + "`.`sample` (id bigint, data string);");
```
### Schreiben Sie an einen Iceberg-Tabelle
**Flink SQL**
```
INSERT INTO `glue_catalog`.``.`sample` values (1, 'a'),(2,'b'),(3,'c');
```
**Tabellen-API**
```
tEnv.executeSql(
"INSERT INTO `glue_catalog`.`"
+ db
+ "`.`sample` values (1, 'a'),(2,'b'),(3,'c');");
```
**Datenstream-API**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
GenericRowData rowData1 = new GenericRowData(2);
rowData1.setField(0, 1L);
rowData1.setField(1, StringData.fromString("a"));
DataStream input = env.fromElements(rowData1);
Map props = new HashMap<();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStreamSink dataStreamSink =
FlinkSink.forRowData(input).tableLoader(tableLoader).append();
env.execute("Datastream Write");
```
### Lesen von einer Iceberg-Tabelle
**Flink SQL**
```
SELECT * FROM `glue_catalog`.``.`sample`;
```
**Tabellen-API**
```
Table result = tEnv.sqlQuery("select * from `glue_catalog`.`" + db + "`.`sample`;");
```
**Datenstream-API**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
Map props = new HashMap<>();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStream batch =
FlinkSource.forRowData().env(env).tableLoader(tableLoader).streaming(false).build();
batch.print().name("print-sink");
```
## Verwenden des Hive-Katalogs
Stellen Sie sicher, dass die Abhängigkeiten zwischen Flink und Hive wie unter [Konfigurieren Sie Flink mit Hive Metastore und Glue Catalog](flink-configure.md#flink-configure-hive) beschrieben aufgelöst wurden.
## Flink-Auftrag ausführen
Eine Möglichkeit, einen Auftrag an Flink zu senden, besteht darin, eine Flink-YARN-Sitzung pro Auftrag zu verwenden. Dies kann mit dem folgenden Befehl gestartet werden:
```
sudo flink run -m yarn-cluster -p 4 -yjm 1024m -ytm 4096m $JAR_FILE_NAME
```
## Überlegungen zur Verwendung von Iceberg mit Flink
+ Wenn Sie AWS Glue als Katalog für Iceberg verwenden, stellen Sie sicher, dass die Datenbank, in der Sie eine Tabelle erstellen, in AWS Glue vorhanden ist. Wenn Sie Dienste wie verwenden AWS Lake Formation und den Katalog nicht laden können, stellen Sie sicher, dass Sie über den richtigen Zugriff auf den Dienst verfügen, um den Befehl auszuführen.
+ Die Iceberg Glue-Integration funktioniert nicht mit dem Redshift Managed Storage-Katalog.
# Verwenden Sie einen Iceberg-Cluster mit Hive
Mit Amazon-EMR-Versionen 6.9.0 und höher können Sie Iceberg mit einem Hive-Cluster verwenden, ohne die Einrichtungsschritte durchführen zu müssen, die für Open Source Iceberg Hive Integration erforderlich sind. Für Amazon-EMR-Versionen 6.8.0 und früher können Sie eine Bootstrap-Aktion verwenden, um `iceberg-hive-runtime` JAR für die Konfiguration von Hive für die Iceberg-Unterstützung zu installieren.
Amazon EMR 6.9.0 umfasst alle Features für die [Hive-3.1.3-Integration mit Iceberg 0.14.1](https://iceberg.apache.org/releases/#0140-release) und enthält auch zusätzliche Amazon-EMR-Features wie die automatische Auswahl unterstützter Ausführungs-Engines zur Laufzeit (Amazon EMR auf EKS 6.9.0).
## Erstellen Sie einen Iceberg-Cluster
Sie können einen Cluster mit installiertem Iceberg mithilfe der AWS-Managementkonsole, der AWS CLI oder der Amazon EMR-API erstellen. In diesem Tutorial verwenden Sie den, AWS CLI um mit Iceberg auf einem Amazon EMR-Cluster zu arbeiten. Um mit der Konsole einen Cluster mit installiertem Iceberg zu erstellen, folgen Sie den Schritten unter [Ein Data Lake von Apache Iceberg mit Amazon Athena, Amazon EMR und AWS Glue erstellen](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Um Iceberg auf Amazon EMR mit dem zu verwenden AWS CLI, erstellen Sie zunächst einen Cluster mit den folgenden Schritten. Informationen zur Spezifizierung der Iceberg-Klassifizierung mithilfe des AWS CLI oder des Java-SDK finden Sie unter oder. [Geben Sie AWS CLI beim Erstellen eines Clusters eine Konfiguration an, indem Sie](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Beim Erstellen eines Clusters eine Konfiguration mit dem Java SDK angeben](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk) Erstellen Sie eine Datei mit dem Namen `configurations.json` und dem folgenden Inhalt:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
Erstellen Sie als Nächstes einen Cluster mit der folgenden Konfiguration und ersetzen Sie dabei den Amazon-S3-Bucket-Beispielpfad und die Subnetz-ID durch Ihre eigene:
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Hive \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_hive_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Ein Hive-Iceberg-Cluster macht die folgenden Dinge:
+ Lädt das Iceberg Hive-Laufzeit-Jar in Hive und aktiviert die Iceberg-bezogene Konfiguration für die Hive-Engine.
+ Aktiviert die dynamische Ausführungs-Engine-Auswahl von Amazon EMR Hive, um zu verhindern, dass Benutzer die unterstützte Ausführungs-Engine für die Iceberg-Kompatibilität einrichten.
**Anmerkung**
Hive Iceberg-Cluster unterstützen AWS Glue Data Catalog derzeit nicht. Der Standard-Iceberg-Katalog ist `HiveCatalog`, was dem für die Hive-Umgebung konfigurierten Metastore entspricht. Weitere Informationen zur Katalogverwaltung finden Sie unter [Verwenden HCatalog](https://cwiki.apache.org/confluence/display/Hive/HCatalog+UsingHCat#HCatalogUsingHCat-UsingHCatalog) in der [Apache Hive-Dokumentation](https://cwiki.apache.org/confluence/display/HIVE).
## Feature-Unterstützung
Amazon EMR 6.9.0 unterstützt Hive 3.1.3 und Iceberg 0.14.1. Die Featureunterstützung ist auf Iceberg-kompatible Feature für Hive 3.1.2 und 3.1.3 beschränkt. Die folgenden -Befehle sind verfügbar:
+ Bei den Amazon-EMR-Versionen 6.9.0 bis 6.12.x müssen Sie das `libfb303`-JAR in das Hive-`auxlib`-Verzeichnis aufnehmen. Verwenden Sie den folgenden Befehl, um es einzubinden:
```
sudo /usr/bin/ln -sf /usr/lib/hive/lib/libfb303-*.jar /usr/lib/hive/auxlib/libfb303.jar
```
Bei Amazon-EMR-Versionen 6.13 und höher wird das `libfb303`-JAR automatisch mit dem Hive-`auxlib`-Verzeichnis verknüpft.
+ **Erstellen einer Tabelle**
+ **Nicht partitionierte Tabelle** – Externe Tabellen in Hive können erstellt werden, indem der Storage-Handler wie folgt bereitgestellt wird:
```
CREATE EXTERNAL TABLE x (i int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
+ **Partitionierte Tabelle** – Externe partitionierte Tabellen in Hive können wie folgt erstellt werden:
```
CREATE EXTERNAL TABLE x (i int) PARTITIONED BY (j int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
**Anmerkung**
Das `STORED AS` Dateiformat von ORC/AVRO/PARQUET wird in Hive 3 nicht unterstützt. Die Standardoption und einzige Option ist Parquet.
+ **Tabelle löschen** – Der `DROP TABLE`-Befehl wird verwendet, um Tabellen zu löschen, wie im folgenden Beispiel:
```
DROP TABLE [IF EXISTS] table_name [PURGE];
```
+ **Eine Tabelle lesen** – `SELECT`-Anweisungen können verwendet werden, um Iceberg-Tabellen in Hive zu lesen, wie im folgenden Beispiel. Unterstützte Ausführungs-Engines sind MR und Tez.
```
SELECT * FROM table_name
```
[Informationen zur Select-Syntax von Hive finden Sie unter LanguageManual Select.](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Select) Informationen zu Select-Anweisungen mit Iceberg-Tabellen in Hive finden Sie unter [Apache Iceberg Select.](https://iceberg.apache.org/docs/latest/hive/#select)
+ **In eine Tabelle einfügen** – Die `INSERT INTO`-HiveQL-Anweisung funktioniert nur für Iceberg-Tabellen mit Unterstützung für die Map-Reduce-Ausführungsengine. Amazon-EMR-Benutzer müssen die Ausführungs-Engine nicht explizit festlegen, da Amazon EMR Hive die Engine für Iceberg Tables zur Laufzeit auswählt.
+ **Einzelne Tabelle einfügen in** – Beispiel:
```
INSERT INTO table_name VALUES ('a', 1);
INSERT INTO table_name SELECT...;
```
+ **Einfügen in mehrere Tabellen** – Das Einfügen in Anweisungen, die nicht aus mehreren Tabellen bestehen, werden unterstützt. Beispiel:
```
FROM source
INSERT INTO table_1 SELECT a, b
INSERT INTO table_2 SELECT c,d;
```
Ab Amazon EMR 7.3.0 unterstützt Hive with Iceberg den AWS Glue-Datenkatalog als Metastore. Um den AWS Glue-Datenkatalog als Metastore zu verwenden, legen Sie die folgende Eigenschaft fest.
```
SET iceberg.catalog..catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog;
```
Alternativ können Sie auch die folgende Eigenschaft festlegen.
```
SET iceberg.catalog..type=glue;
```
Anschließend können Sie anhand des folgenden Beispiels eine Tabelle erstellen.
```
CREATE EXTERNAL TABLE table_name (col1 type1, col2 type2,..)
ROW FORMAT SERDE 'org.apache.iceberg.mr.hive.HiveIcebergSerDe'
STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
location ''
TBLPROPERTIES ('table_type'='iceberg', 'iceberg.catalog'='');
```
## Überlegungen zur Verwendung von Iceberg mit Hive
+ Iceberg unterstützt die folgenden Abfragetypen:
+ Tabelle erstellen
+ Drop table
+ In die Tabelle einfügen
+ Tabelle lesen
+ Nur die MR (MapReduce) -Ausführungsengine wird für DML-Operationen (Data Manipulation Language) unterstützt, und MR ist in Hive 3.1.3 veraltet.
+ Für Amazon EMR vor 7.3.0 wird AWS Glue Data Catalog derzeit nicht für Iceberg with Hive unterstützt.
+ Die Fehlerbehandlung ist nicht robust genug. Im Falle einer Fehlkonfiguration können Einfügungen in Abfragen erfolgreich abgeschlossen werden. Wenn Metadaten nicht aktualisiert werden, kann das jedoch zu Datenverlust führen.
+ Die Iceberg Glue-Integration funktioniert nicht mit dem Redshift Managed Storage-Katalog.