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.
# Apache Spark
[Apache Spark](https://aws.amazon.com/emr/features/spark/) ist ein verteiltes Verarbeitungs-Framework und Programmiermodell, mit dem Sie Machine Learning, Stream-Verarbeitung oder Graph-Analysen mit Amazon-EMR-Clustern durchführen können. Ähnlich wie Apache Hadoop ist Spark ein verteiltes Open-Source-Verarbeitungssystem, das häufig für Big-Data-Workloads verwendet wird. Spark weist jedoch einige bemerkenswerte Unterschiede zu Hadoop MapReduce auf. Spark hat eine optimierte DAG-Ausführungs-Engine (Directed Acyclic Graph, gerichteter azyklischer Graph) und betreibt aktives In-Memory-Caching für Daten. Dies kann die Leistung insbesondere für bestimmte Algorithmen und interaktive Abfragen steigern.
Spark unterstützt standardmäßig Anwendungen, die in Scala, Java und Python geschrieben sind. Es enthält auch mehrere eng integrierte Bibliotheken für SQL ([Spark](https://spark.apache.org/sql/)), maschinelles Lernen ([MLlib](https://spark.apache.org/mllib/)), Stream-Verarbeitung ([Spark-Streaming](https://spark.apache.org/streaming/)) und Graphverarbeitung ([GraphX](https://spark.apache.org/graphx/)). Diese Tools vereinfachen die Nutzung des Spark-Frameworks für eine Vielzahl von Anwendungsfällen.
Sie können Spark zusammen mit anderen Hadoop-Anwendungen auf einem Amazon-EMR-Cluster installieren. Es kann außerdem das Amazon-EMR-Dateisystem (EMRFS) nutzen, um direkt auf Daten in Amazon S3 zuzugreifen. Hive ist auch in Spark integriert, sodass Sie ein HiveContext Objekt verwenden können, um Hive-Skripte mit Spark auszuführen. Ein Hive-Kontext ist als `sqlContext` Bestandteil der Spark-Shell.
Ein Beispiel-Tutorial zur Einrichtung eines EMR-Clusters mit Spark und zur Analyse eines Beispieldatensatzes finden Sie unter [Tutorial: Erste Schritte mit Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html) im AWS News-Blog.
Sie können den Apache Spark Troubleshooting Agent verwenden, um Fehler bei Ihren Apache Spark-Anwendungen auf EMR on EC2 und EMR Serverless zu beheben. Weitere Informationen finden Sie unter. [Was ist der Apache Spark Troubleshooting Agent für Amazon EMR](spark-troubleshoot.md)
**Wichtig**
Apache-Spark-Version 2.3.1, verfügbar ab Amazon-EMR-Version 5.16.0, adressiert [CVE-2018-8024](https://nvd.nist.gov/vuln/detail/CVE-2018-8024) und [CVE-2018-1334.](https://nvd.nist.gov/vuln/detail/CVE-2018-1334) Wir empfehlen, dass Sie frühere Versionen von Spark zu Spark-Version 2.3.1 oder höher migrieren.
Die folgende Tabelle listet die Version von Spark auf, die in der neuesten Version der Amazon-EMR-7.x-Serie enthalten ist, zusammen mit den Komponenten, die Amazon EMR mit Spark installiert.
Die Version der Komponenten, die in dieser Version mit Spark installiert wurden, finden Sie unter [Komponentenversionen von Version 7.12.0](emr-7120-release.md).
**Spark-Versionsinformationen für emr-7.12.0**
| Amazon-EMR-Versionsbezeichnung | Spark-Version | Mit Spark installierte Komponenten |
| --- | --- | --- |
| emr-7.12.0 | Spark 3.5.6-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
Die folgende Tabelle listet die Version von Spark auf, die in der neuesten Version der Amazon-EMR-6.x-Serie enthalten ist, zusammen mit den Komponenten, die Amazon EMR mit Spark installiert.
Die Version der Komponenten, die mit Spark in dieser Version installiert wurden, finden Sie unter [Komponentenversionen der Version 6.15.0](emr-6150-release.md).
**Spark-Versionsinformationen für emr-6.15.0**
| Amazon-EMR-Versionsbezeichnung | Spark-Version | Mit Spark installierte Komponenten |
| --- | --- | --- |
| emr-6.15.0 | Spark 3.4.1-amzn-2 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
**Anmerkung**
Amazon-EMR-Version 6.8.0 wird mit Apache Spark 3.3.0 geliefert. Diese Spark-Version verwendet Apache Log4j 2 und die `log4j2.properties`-Datei zur Konfiguration von Log4j in Spark-Prozessen. Wenn Sie Spark im Cluster verwenden oder EMR-Cluster mit benutzerdefinierten Konfigurationsparametern erstellen und ein Upgrade auf Amazon-EMR-Version 6.8.0 durchführen möchten, müssen Sie auf die neue `spark-log4j2`-Konfigurationsklassifizierung und das neue Schlüsselformat für Apache Log4j 2 migrieren. Weitere Informationen finden Sie unter [Migration von Apache Log4j 1.x zu Log4j 2.x](emr-spark-configure.md#spark-migrate-logj42).
Die folgende Tabelle listet die Version von Spark auf, die in der neuesten Version der Amazon-EMR-5.x-Serie enthalten ist, zusammen mit den Komponenten, die Amazon EMR mit Spark installiert.
[Informationen zur Version der Komponenten, die in dieser Version mit Spark installiert wurden, finden Sie unter Komponentenversionen von Version 5.36.2.](emr-5362-release.md)
**Spark-Versionsinformationen für emr-5.36.2**
| Amazon-EMR-Versionsbezeichnung | Spark-Version | Mit Spark installierte Komponenten |
| --- | --- | --- |
| emr-5.36.2 | Spark 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
**Topics**
+ [Einen Cluster mit Apache Spark erstellen](emr-spark-launch.md)
+ [Spark-Anwendungen mit Docker mithilfe von Amazon EMR 6.x ausführen](emr-spark-docker.md)
+ [Verwenden Sie den AWS Glue Data Catalog-Katalog mit Spark auf Amazon EMR](emr-spark-glue.md)
+ [Arbeiten mit einer Hierarchie mit mehreren Katalogen in AWS Glue Data Catalog mit Spark auf Amazon EMR](emr-multi-catalog.md)
+ [Konfigurieren von Spark](emr-spark-configure.md)
+ [Was ist der Apache Spark Troubleshooting Agent für Amazon EMR](spark-troubleshoot.md)
+ [Die Leistung von Spark optimieren](emr-spark-performance.md)
+ [Caching von Ergebnisfragmenten in Spark](emr-spark-fragment-result-caching.md)
+ [Den Nvidia-RAPIDS-Accelerator für Apache Spark verwenden](emr-spark-rapids.md)
+ [Zugriff auf die Spark-Shell](emr-spark-shell.md)
+ [Verwenden Sie Amazon SageMaker Spark für maschinelles Lernen](emr-spark-sagemaker.md)
+ [Eine Spark-Anwendung schreiben](emr-spark-application.md)
+ [Verbessern der Spark Leistung mit Amazon S3](emr-spark-s3-performance.md)
+ [Einen Spark-Schritt hinzufügen](emr-spark-submit-step.md)
+ [Anzeigen des Spark-Anwendungsverlaufs](emr-spark-application-history.md)
+ [Greifen Sie auf das Spark-Web zu UIs](emr-spark-webui.md)
+ [Verwenden des Amazon Kinesis Data Streams-Connectors für strukturiertes Streaming mit Spark](emr-spark-structured-streaming-kinesis.md)
+ [Amazon-Redshift-Integration für Apache Spark mit Amazon EMR verwenden](emr-spark-redshift.md)
+ [Spark-Versionsverlauf](Spark-release-history.md)
+ [Materialisierte Ansichten mit Amazon EMR verwenden](emr-spark-materialized-views.md)
# Einen Cluster mit Apache Spark erstellen
Mit der folgenden Prozedur wird ein Cluster mit [Spark](https://aws.amazon.com/big-data/what-is-spark/) erstellt, der mithilfe von **Quick Options** (Optionen für das schnelle Erstellen eines Clusters) in der Amazon-EMR-Konsole installiert wurde.
Sie können alternativ **Erweiterte Optionen** verwenden, um Ihre Cluster-Einrichtung weiter anzupassen oder Schritte zur programmgesteuerten Installation von Anwendungen und zur anschließenden Ausführung benutzerdefinierter Anwendungen zu senden. Bei diesen beiden erweiterten Optionen zur Clustererstellung können Sie AWS Glue als Spark-SQL-Metastore verwenden. Weitere Informationen finden Sie unter [Verwenden Sie den AWS Glue Data Catalog-Katalog mit Spark auf Amazon EMR](emr-spark-glue.md).
**So starten Sie einen Cluster mit installiertem Spark**
1. Öffnen Sie die Amazon EMR-Konsole unter [https://console.aws.amazon.com/emr](https://console.aws.amazon.com/emr/).
1. Wählen Sie **Cluster erstellen** aus, um **Schnelle Optionen** zu verwenden.
1. Geben Sie einen **Clusternamen** ein. Ihr Clustername darf die Zeichen <, >, \$1, \$1 oder `(Backtick) nicht enthalten.
1. Wählen Sie unter **Softwarekonfiguration** die Option **Version** aus.
1. Wählen Sie für **Anwendungen** das **Spark**-Anwendungspaket.
1. Wählen Sie nach Bedarf weitere Optionen und anschließend **Create cluster (Cluster erstellen)** aus.
**Anmerkung**
Weitere Informationen zum Konfigurieren von Spark beim Erstellen des Clusters finden Sie unter [Konfigurieren von Spark](emr-spark-configure.md).
**Um einen Cluster mit installiertem Spark zu starten, verwenden Sie AWS CLI**
+ Erstellen Sie den Cluster mit dem folgenden Befehl.
```
aws emr create-cluster --name "Spark cluster" --release-label emr-7.12.0 --applications Name=Spark \
--ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 --use-default-roles
```
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
**So starten Sie einen Cluster mit installiertem Spark über SDK für Java**
Geben Sie Spark als Anwendung mit `SupportedProductConfig` an, die in `RunJobFlowRequest` verwendet wird.
+ Das folgende Beispiel zeigt, wie Sie einen Cluster mit Spark mittels Java erstellen.
```
import com.amazonaws.AmazonClientException;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.elasticmapreduce.AmazonElasticMapReduce;
import com.amazonaws.services.elasticmapreduce.AmazonElasticMapReduceClientBuilder;
import com.amazonaws.services.elasticmapreduce.model.*;
import com.amazonaws.services.elasticmapreduce.util.StepFactory;
public class Main {
public static void main(String[] args) {
AWSCredentials credentials_profile = null;
try {
credentials_profile = new ProfileCredentialsProvider("default").getCredentials();
} catch (Exception e) {
throw new AmazonClientException(
"Cannot load credentials from .aws/credentials file. " +
"Make sure that the credentials file exists and the profile name is specified within it.",
e);
}
AmazonElasticMapReduce emr = AmazonElasticMapReduceClientBuilder.standard()
.withCredentials(new AWSStaticCredentialsProvider(credentials_profile))
.withRegion(Regions.US_WEST_1)
.build();
// create a step to enable debugging in the AWS Management Console
StepFactory stepFactory = new StepFactory();
StepConfig enabledebugging = new StepConfig()
.withName("Enable debugging")
.withActionOnFailure("TERMINATE_JOB_FLOW")
.withHadoopJarStep(stepFactory.newEnableDebuggingStep());
Application spark = new Application().withName("Spark");
RunJobFlowRequest request = new RunJobFlowRequest()
.withName("Spark Cluster")
.withReleaseLabel("emr-5.20.0")
.withSteps(enabledebugging)
.withApplications(spark)
.withLogUri("s3://path/to/my/logs/")
.withServiceRole("EMR_DefaultRole")
.withJobFlowRole("EMR_EC2_DefaultRole")
.withInstances(new JobFlowInstancesConfig()
.withEc2SubnetId("subnet-12ab3c45")
.withEc2KeyName("myEc2Key")
.withInstanceCount(3)
.withKeepJobFlowAliveWhenNoSteps(true)
.withMasterInstanceType("m4.large")
.withSlaveInstanceType("m4.large"));
RunJobFlowResult result = emr.runJobFlow(request);
System.out.println("The cluster ID is " + result.toString());
}
}
```
# Spark-Anwendungen mit Docker mithilfe von Amazon EMR 6.x ausführen
**Anmerkung**
Das beschriebene Verfahren funktioniert nur mit Amazon EMR Version 6.x.
Mit Amazon EMR 6.0.0 können Spark-Anwendungen Docker-Container für die Definition von Bibliotheksabhängigkeiten verwenden, anstatt Abhängigkeiten auf den einzelnen Amazon-EC2-Instances im Cluster zu installieren. Wenn Sie Spark mit Docker ausführen möchten, müssen Sie zunächst die Docker-Registrierung konfigurieren und beim Senden einer Spark-Anwendung zusätzliche Parameter definieren. Weitere Informationen finden Sie unter [Konfigurieren der Docker-Integration](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).
Wenn die Anwendung gesendet wird, ruft YARN Docker auf, um das angegebene Docker-Image abzurufen und die Spark-Anwendung in einem Docker-Container auszuführen. Auf diese Weise können Sie Abhängigkeiten einfach definieren und isolieren. Dadurch wird die Zeit reduziert, die für das Bootstrapping oder das Vorbereiten von Instances im Amazon-EMR-Cluster mit den für die Aufgabenausführung erforderlichen Bibliotheken notwendig ist.
## Überlegungen beim Ausführen von Spark mit Docker
Stellen Sie beim Ausführen von Spark mit Docker sicher, dass die folgenden Voraussetzungen erfüllt sind:
+ Das `docker`-Paket und die CLI werden nur auf Kern- und Aufgabenknoten installiert.
+ In Amazon EMR 6.1.0 und höher können Sie Docker alternativ mit den folgenden Befehlen auf einem Primärknoten installieren.
+
```
sudo yum install -y docker
sudo systemctl start docker
```
+ Der `spark-submit`-Befehl sollte immer von einer primären-Instance auf dem Amazon-EMR-Cluster ausgeführt werden.
+ Die Docker-Register, die zum Auflösen von Docker-Images verwendet werden, müssen mithilfe der Klassifikations-API mit dem `container-executor`-Klassifizierungsschlüssel definiert werden, um beim Starten des Clusters zusätzliche Parameter zu definieren:
+ `docker.trusted.registries`
+ `docker.privileged-containers.registries`
+ Wenn Sie eine Spark-Anwendung in einem Docker-Container ausführen möchten, sind die folgenden Konfigurationsoptionen erforderlich:
+ `YARN_CONTAINER_RUNTIME_TYPE=docker`
+ `YARN_CONTAINER_RUNTIME_DOCKER_IMAGE={DOCKER_IMAGE_NAME}`
+ Beim Abrufen von Docker-Images mit Amazon ECR müssen Sie den Cluster so konfigurieren, dass er sich authentifiziert. Dazu müssen Sie die folgende Konfigurationsoption verwenden:
+ YARN\$1CONTAINER\$1RUNTIME\$1DOCKER\$1CLIENT\$1CONFIG= \$1DOCKER\$1CLIENT\$1CONFIG\$1PATH\$1ON\$1HDFS\$1
+ In Amazon EMR 6.1.0 und höher müssen Sie den aufgelisteten Befehl `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG={DOCKER_CLIENT_CONFIG_PATH_ON_HDFS}` nicht verwenden, wenn das automatische ECR-Authentifizierungsfeature aktiviert ist.
+ Bei jedem Docker-Image, das mit Spark verwendet wird, muss Java im Docker-Image installiert sein.
Weitere Informationen zu den Voraussetzungen finden Sie unter [Konfigurieren der Docker-Integration](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).
## Ein Docker-Image erstellen
Docker-Images werden mit einer Docker-Datei erstellt, in der die Pakete und die Konfiguration definiert werden, die in das Image aufgenommen werden sollen. Die folgenden beiden Beispiele verwenden Dockerfiles PySpark und SparkR.
**PySpark Docker-Datei**
Docker-Images, die aus dieser Dockerfile erstellt wurden, enthalten Python 3 und das NumPy Python-Paket. Diese Docker-Datei verwendet Amazon Linux 2 und Amazon Corretto JDK 8.
```
FROM amazoncorretto:8
RUN yum -y update
RUN yum -y install yum-utils
RUN yum -y groupinstall development
RUN yum list python3*
RUN yum -y install python3 python3-dev python3-pip python3-virtualenv
RUN python -V
RUN python3 -V
ENV PYSPARK_DRIVER_PYTHON python3
ENV PYSPARK_PYTHON python3
RUN pip3 install --upgrade pip
RUN pip3 install numpy pandas
RUN python3 -c "import numpy as np"
```
**SparkR-Docker-Datei**
Docker-Images, die aus dieser Docker-Datei erstellt werden, enthalten R und das CRAN-Paket „randomForest“. Diese Docker-Datei enthält Amazon Linux 2 und Amazon Corretto JDK 8.
```
FROM amazoncorretto:8
RUN java -version
RUN yum -y update
RUN amazon-linux-extras install R4
RUN yum -y install curl hostname
#setup R configs
RUN echo "r <- getOption('repos'); r['CRAN'] <- 'http://cran.us.r-project.org'; options(repos = r);" > ~/.Rprofile
RUN Rscript -e "install.packages('randomForest')"
```
Weitere Informationen zur Docker-Dateisyntax finden Sie in der [Docker-Datei-Referenzdokumentation](https://docs.docker.com/engine/reference/builder/).
## Verwenden von Docker-Images von Amazon ECR
Amazon Elastic Container Registry (Amazon ECR) ist eine vollständig verwaltete Docker-Container-Registrierung, die das Speichern, Verwalten und Bereitstellen von Docker-Container-Images erleichtert. Wenn Sie Amazon ECR verwenden, muss der Cluster so konfiguriert sein, dass er Ihrer ECR-Instance vertraut, und Sie müssen die Authentifizierung konfigurieren, damit der Cluster Docker-Images aus Amazon ECR verwenden kann. Weitere Informationen finden Sie unter [Konfigurieren von YARN für den Zugriff auf Amazon ECR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html#emr-docker-ECR).
Um sicherzustellen, dass Amazon-EMR-Hosts auf die in Amazon ECR gespeicherten Images zugreifen können, muss der Cluster über die Berechtigungen der `AmazonEC2ContainerRegistryReadOnly`-Richtlinie verfügen, die dem Instance-Profil zugeordnet ist. Weitere Informationen finden Sie unter [`AmazonEC2ContainerRegistryReadOnly`-Richtlinie](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ecr_managed_policies.html#AmazonEC2ContainerRegistryReadOnly).
In diesem Beispiel muss der Cluster mit der folgenden zusätzlichen Konfiguration erstellt werden, um sicherzustellen, dass die Amazon-ECR-Registrierung vertrauenswürdig ist. Ersetzen Sie den *123456789123.dkr.ecr.us-east-1.amazonaws.com* Endpunkt durch Ihren Amazon ECR-Endpunkt.
```
[
{
"Classification": "container-executor",
"Configurations": [
{
"Classification": "docker",
"Properties": {
"docker.privileged-containers.registries": "local,centos,123456789123.dkr.ecr.us-east-1.amazonaws.com",
"docker.trusted.registries": "local,centos,123456789123.dkr.ecr.us-east-1.amazonaws.com"
}
}
],
"Properties": {}
}
]
```
**Verwendung PySpark mit Amazon ECR**
Das folgende Beispiel verwendet das PySpark Dockerfile, das markiert und in Amazon ECR hochgeladen wird. Nachdem Sie das Dockerfile hochgeladen haben, können Sie den PySpark Job ausführen und auf das Docker-Image von Amazon ECR verweisen.
Nachdem Sie den Cluster gestartet haben, verwenden Sie SSH, um eine Verbindung zu einem Kernknoten herzustellen, und führen Sie die folgenden Befehle aus, um das lokale Docker-Image aus dem Dockerfile-Beispiel zu erstellen. PySpark
Erstellen Sie zunächst ein Verzeichnis und eine Docker-Datei.
```
mkdir pyspark
vi pyspark/Dockerfile
```
Fügen Sie den Inhalt der PySpark Dockerfile ein und führen Sie die folgenden Befehle aus, um ein Docker-Image zu erstellen.
```
sudo docker build -t local/pyspark-example pyspark/
```
Erstellen Sie das `emr-docker-examples`-ECR-Repository für die Beispiele.
```
aws ecr create-repository --repository-name emr-docker-examples
```
Markieren Sie das lokal erstellte Image und laden Sie es in ECR hoch. Ersetzen *123456789123.dkr.ecr.us-east-1.amazonaws.com* Sie es durch Ihren ECR-Endpunkt.
```
sudo docker tag local/pyspark-example 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example
sudo docker push 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example
```
Verwenden Sie SSH, um eine Verbindung mit dem Primärknoten herzustellen und ein Python-Skript mit dem Dateinamen „`main.py`“ vorzubereiten. Fügen Sie den folgenden Inhalt in die `main.py`-Datei ein und speichern Sie sie.
```
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("docker-numpy").getOrCreate()
sc = spark.sparkContext
import numpy as np
a = np.arange(15).reshape(3, 5)
print(a)
```
Verweisen Sie unter Amazon EMR 6.0.0 zum Übermitteln des Auftrags auf den Namen des Docker-Images. Definieren Sie die zusätzlichen Konfigurationsparameter, um sicherzustellen, dass die Aufgabenausführung Docker als Laufzeit verwendet. Bei Verwendung von Amazon ECR muss `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` sich der auf die `config.json`-Datei beziehen, in der die Anmeldeinformationen enthalten sind, die zur Authentifizierung bei Amazon ECR verwendet werden.
```
DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example
DOCKER_CLIENT_CONFIG=hdfs:///user/hadoop/config.json
spark-submit --master yarn \
--deploy-mode cluster \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \
--num-executors 2 \
main.py -v
```
Verweisen Sie unter Amazon EMR 6.1.0 oder höher zum Übermitteln des Auftrags auf den Namen des Docker-Images. Wenn die automatische ECR-Authentifizierung aktiviert ist, führen Sie den folgenden Befehl aus.
```
DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example
spark-submit --master yarn \
--deploy-mode cluster \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--num-executors 2 \
main.py -v
```
Wenn der Job abgeschlossen ist, notieren Sie sich die YARN-Anwendungs-ID und verwenden Sie den folgenden Befehl, um die Ausgabe des PySpark Jobs abzurufen.
```
yarn logs --applicationId application_id | grep -C2 '\[\['
LogLength:55
LogContents:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
```
**SparkR mit Amazon ECR verwenden**
Im folgenden Beispiel wird die SparkR-Docker-Datei verwendet, die markiert und in ECR hochgeladen wird. Sobald die Docker-Datei hochgeladen wurde, können Sie die SparkR-Aufgabe ausführen und auf das Docker-Image von Amazon ECR verweisen.
Nachdem Sie den Cluster gestartet haben, verwenden Sie SSH, um eine Verbindung mit einem Core-Knoten herzustellen, und führen Sie die folgenden Befehle aus, um das lokale Docker-Image aus dem Beispiel für die SparkR-Docker-Datei zu erstellen.
Erstellen Sie zunächst ein Verzeichnis und die Docker-Datei.
```
mkdir sparkr
vi sparkr/Dockerfile
```
Fügen Sie den Inhalt der SparkR-Docker-Datei ein, und führen Sie die folgenden Befehle aus, um ein Docker-Image zu erstellen.
```
sudo docker build -t local/sparkr-example sparkr/
```
Markieren Sie das lokal erstellte Image und laden Sie es auf Amazon ECR hoch. *123456789123.dkr.ecr.us-east-1.amazonaws.com* Ersetzen Sie es durch Ihren Amazon ECR-Endpunkt.
```
sudo docker tag local/sparkr-example 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example
sudo docker push 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example
```
Verwenden Sie SSH, um eine Verbindung zum Primärknoten herzustellen und ein R-Skript mit dem Namen `sparkR.R` vorzubereiten. Fügen Sie den folgenden Inhalt in die `sparkR.R`-Datei ein:
```
library(SparkR)
sparkR.session(appName = "R with Spark example", sparkConfig = list(spark.some.config.option = "some-value"))
sqlContext <- sparkRSQL.init(spark.sparkContext)
library(randomForest)
# check release notes of randomForest
rfNews()
sparkR.session.stop()
```
Verweisen Sie unter Amazon EMR 6.0.0 zum Übermitteln des Auftrags auf den Namen des Docker-Images. Definieren Sie die zusätzlichen Konfigurationsparameter, um sicherzustellen, dass die Aufgabenausführung Docker als Laufzeit verwendet. Bei Verwendung von Amazon ECR muss `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` sich der auf die `config.json`-Datei beziehen, in der die Anmeldeinformationen enthalten sind, die zur Authentifizierung bei ECR verwendet werden.
```
DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example
DOCKER_CLIENT_CONFIG=hdfs:///user/hadoop/config.json
spark-submit --master yarn \
--deploy-mode cluster \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \
sparkR.R
```
Verweisen Sie unter Amazon EMR 6.1.0 oder höher zum Übermitteln des Auftrags auf den Namen des Docker-Images. Wenn die automatische ECR-Authentifizierung aktiviert ist, führen Sie den folgenden Befehl aus.
```
DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example
spark-submit --master yarn \
--deploy-mode cluster \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
sparkR.R
```
Wenn die Aufgabe abgeschlossen ist, notieren Sie sich die YARN-Anwendungs-ID, und verwenden Sie den folgenden Befehl, um die Ausgabe der SparkR-Aufgabe abzurufen. Dieses Beispiel enthält Tests, um sicherzustellen, dass die randomForest-Bibliothek, die installierte Version und die Versionshinweise verfügbar sind.
```
yarn logs --applicationId application_id | grep -B4 -A10 "Type rfNews"
randomForest 4.6-14
Type rfNews() to see new features/changes/bug fixes.
Wishlist (formerly TODO):
* Implement the new scheme of handling classwt in classification.
* Use more compact storage of proximity matrix.
* Allow case weights by using the weights in sampling?
========================================================================
Changes in 4.6-14:
```
# Verwenden Sie den AWS Glue Data Catalog-Katalog mit Spark auf Amazon EMR
Mit Amazon EMR Version 5.8.0 oder höher können Sie Spark so konfigurieren, dass der AWS Glue-Datenkatalog als Apache Hive-Metastore verwendet wird. Wir empfehlen diese Konfiguration, wenn Sie einen persistenten Hive-Metastore oder einen Hive-Metastore benötigen, der von verschiedenen Clustern, Diensten, Anwendungen oder Konten gemeinsam genutzt wird. AWS
Mit Amazon EMR Version 6.5.0 oder höher können Sie Spark so konfigurieren, dass der AWS Glue-Datenkatalog mit Apache Iceberg verwendet wird.
Mit Amazon EMR Version 7.5.0 oder höher können Sie Spark so konfigurieren, dass der AWS Glue-Datenkatalog als Iceberg-REST-Katalog verwendet wird.
AWS Glue ist ein vollständig verwalteter ETL-Service (Extrahieren, Transformieren und Laden), mit dem Sie Ihre Daten einfach und kostengünstig kategorisieren, bereinigen, anreichern und zuverlässig zwischen verschiedenen Datenspeichern verschieben können. Der AWS Glue Data Catalog bietet ein einheitliches Metadaten-Repository für eine Vielzahl von Datenquellen und Datenformaten, das sich in Amazon EMR sowie Amazon RDS, Amazon Redshift, Redshift Spectrum, Athena und jede mit dem Apache Hive Metastore kompatible Anwendung integrieren lässt. AWS Glue-Crawler können automatisch Schemas aus Quelldaten in Amazon S3 ableiten und die zugehörigen Metadaten im Datenkatalog speichern. Weitere Informationen zum Datenkatalog finden Sie unter [Auffüllen des AWS Glue-Datenkatalogs](https://docs.aws.amazon.com/glue/latest/dg/populate-data-catalog.html) im *AWS Glue-Entwicklerhandbuch*.
Für AWS Glue fallen separate Gebühren an. Es gibt eine monatliche Gebühr für das Speichern und Zugreifen auf die Metadaten im Datenkatalog, einen Stundensatz, der pro Minute für AWS Glue ETL-Jobs und Crawler-Laufzeit abgerechnet wird, und einen Stundensatz, der pro Minute für jeden bereitgestellten Entwicklungsendpunkt abgerechnet wird. Der Datenkatalog ermöglicht Ihnen die gebührenfreie Speicherung von bis zu einer Million Objekten. Wenn Sie mehr als eine Million Objekte speichern, fällt eine Gebühr von 1 USD für jeweils 100.000 zusätzliche Objekte an. Im Data Catalog ist ein Objekt eine Tabelle, eine Partition oder eine Datenbank. Weitere Informationen finden Sie unter [Glue-Preise](https://aws.amazon.com/glue/pricing).
**Wichtig**
Wenn Sie vor dem 14. August 2017 Tabellen mit Amazon Athena oder Amazon Redshift Spectrum erstellt haben, werden Datenbanken und Tabellen in einem von Athena verwalteten Katalog gespeichert, der vom Glue-Datenkatalog getrennt ist. AWS Um Amazon EMR mit diesen Tabellen zu integrieren, müssen Sie ein Upgrade auf den AWS Glue Data Catalog durchführen. Weitere Informationen finden Sie unter [Upgrade auf den AWS Glue-Datenkatalog](https://docs.aws.amazon.com/athena/latest/ug/glue-upgrade.html) im *Amazon Athena Athena-Benutzerhandbuch*.
## AWS Glue Data Catalog als Apache Hive-Metastore angeben
Sie können den AWS Glue-Datenkatalog mithilfe der Amazon EMR-API AWS-Managementkonsole AWS CLI, oder als Metastore angeben. Wenn Sie die CLI oder API verwenden, verwenden Sie die Konfigurationsklassifizierung für Spark, um den Datenkatalog anzugeben. Darüber hinaus können Sie mit Amazon EMR 5.16.0 und höher die Konfigurationsklassifizierung verwenden, um einen Datenkatalog in einem anderen Format anzugeben. AWS-Konto**Wenn Sie die Konsole verwenden, können Sie den Data Catalog mit den **erweiterten Optionen oder den Schnelloptionen** angeben.**
**Anmerkung**
Die Option zur Verwendung von AWS Glue Data Catalog ist auch bei Zeppelin verfügbar, da Zeppelin mit Spark-Komponenten installiert ist.
------
#### [ Console ]
**Um AWS Glue Data Catalog mit der neuen Konsole als Apache Hive-Metastore zu spezifizieren**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon EMR-Konsole unter [https://console.aws.amazon.com/emr](https://console.aws.amazon.com/emr).
1. Wählen Sie im linken Navigationsbereich unter **Amazon EMR in EC2** die Option **Cluster** und dann **Create cluster** (Cluster erstellen) aus.
1. Wählen Sie unter **Anwendungspaket** die Option **Spark** oder **Benutzerdefiniert** aus. Wenn Sie Ihren Cluster anpassen, stellen Sie sicher, dass Sie Zeppelin oder Spark als eine Ihrer Anwendungen auswählen.
1. Aktivieren Sie unter **Einstellungen für den AWS Glue Data Catalog** das Kontrollkästchen **Für Spark-Tabellenmetadaten** verwenden.
1. Wählen Sie alle anderen Optionen aus, die für Ihren Cluster gelten.
1. Um Ihren Cluster jetzt zu starten, wählen Sie **Cluster erstellen** aus.
------
#### [ AWS CLI ]
**Um den AWS Glue-Datenkatalog als Apache Hive-Metastore anzugeben mit dem AWS CLI**
Weitere Informationen zur Angabe einer Konfigurationsklassifizierung mithilfe der AWS CLI Amazon EMR-API finden Sie unter[Anwendungen konfigurieren](emr-configure-apps.md).
+ Geben Sie den Wert für `hive.metastore.client.factory.class` mit der Klassifizierung `spark-hive-site` an, wie in dem folgenden Beispiel gezeigt:
```
[
{
"Classification": "spark-hive-site",
"Properties": {
"hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory"
}
}
]
```
Um einen Datenkatalog in einem anderen AWS Konto anzugeben, fügen Sie die `hive.metastore.glue.catalogid` Eigenschaft hinzu, wie im folgenden Beispiel gezeigt. Ersetzen Sie `acct-id` durch das AWS -Konto des Data Catalog.
```
[
{
"Classification": "spark-hive-site",
"Properties": {
"hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory",
"hive.metastore.glue.catalogid": "acct-id"
}
}
]
```
------
## AWS Glue Data Catalog als Apache Iceberg-Katalog angeben
Sie können den AWS Glue-Datenkatalog als Apache Iceberg-Katalogimplementierung oder als Apache Iceberg-REST-Katalogendpunkt angeben, indem Sie die AWS-Managementkonsole AWS CLI, oder die Amazon EMR-API oder die Laufzeitkonfiguration der Spark-Sitzung verwenden. Wenn Sie die CLI oder API verwenden, verwenden Sie die Konfigurationsklassifizierung für Spark, um den Datenkatalog anzugeben. Weitere Informationen finden Sie unter [AWS Glue Data Catalog als Apache Iceberg-Katalog angeben](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-glue.html#emr-spark-glue-configure-iceberg).
## IAM-Berechtigungen
Das EC2-Instanzprofil für einen Cluster muss über IAM-Berechtigungen für AWS Glue-Aktionen verfügen. Wenn Sie die Verschlüsselung für AWS Glue Data Catalog-Objekte aktivieren, muss die Rolle außerdem berechtigt sein, die für die Verschlüsselung AWS KMS key verwendeten Daten zu verschlüsseln, zu entschlüsseln und zu generieren.
### Berechtigungen für AWS Glue-Aktionen
Wenn Sie das standardmäßige EC2-Instance-Profil für Amazon EMR verwenden, ist keine Aktion erforderlich. Die `AmazonElasticMapReduceforEC2Role` verwaltete Richtlinie, die an die angehängt ist, `EMR_EC2_DefaultRole` ermöglicht alle erforderlichen AWS Glue-Aktionen. Wenn Sie jedoch ein benutzerdefiniertes EC2-Instanzprofil und Berechtigungen angeben, müssen Sie die entsprechenden AWS Glue-Aktionen konfigurieren. Verwenden Sie hierzu die verwaltete Richtlinie `AmazonElasticMapReduceforEC2Role` als Ausgangspunkt. Weitere Informationen finden Sie unter [Servicerolle für Cluster-EC2-Instances (EC2-Instance-Profil)](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-role-for-ec2.html) im *Verwaltungshandbuch für Amazon EMR*.
### Berechtigungen zum Verschlüsseln und Entschlüsseln von AWS Glue Data Catalog
Ihr Instance-Profil benötigt die Erlaubnis, Daten mithilfe Ihres Schlüssels zu verschlüsseln und zu entschlüsseln. Sie müssen diese Berechtigungen *nicht* konfigurieren, wenn die beiden folgenden Aussagen zutreffen:
+ Sie aktivieren die Verschlüsselung für AWS Glue-Datenkatalogobjekte mithilfe verwalteter Schlüssel für AWS Glue.
+ Sie verwenden einen Cluster, der sich im selben Verzeichnis befindet AWS-Konto wie der AWS Glue-Datenkatalog.
Andernfalls müssen Sie die folgende Anweisung der Berechtigungsrichtlinie hinzufügen, die mit Ihrem EC2-Instance-Profil verknüpft ist.
Weitere Informationen zur Verschlüsselung von AWS Glue Data Catalog finden Sie unter [Verschlüsselung Ihres Datenkatalogs](https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html) im *AWS Glue Developer Guide*.
### Ressourcenbasierte Berechtigungen
Wenn Sie AWS Glue in Verbindung mit Hive, Spark oder Presto in Amazon EMR verwenden, unterstützt AWS Glue ressourcenbasierte Richtlinien zur Steuerung des Zugriffs auf Datenkatalogressourcen. Zu diesen Ressourcen gehören Datenbanken, Tabellen, Verbindungen und benutzerdefinierte Funktionen. Weitere Informationen finden Sie unter [Verwenden von ressourcenbasierten Richtlinien für AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-resource-policies.html) im *AWS -Glue-Entwicklerhandbuch*.
Wenn Sie ressourcenbasierte Richtlinien verwenden, um den Zugriff auf AWS Glue von Amazon EMR aus zu beschränken, muss der Principal, den Sie in der Berechtigungsrichtlinie angeben, der Rollen-ARN sein, der dem EC2-Instance-Profil zugeordnet ist, das bei der Erstellung eines Clusters angegeben wird. Für eine ressourcenbasierte Richtlinie, die an einen Katalog angehängt ist, können Sie beispielsweise den Rollen-ARN für die Standarddienstrolle für Cluster-EC2-Instances *EMR\$1EC2\$1DefaultRole* als den angeben, indem Sie das `Principal` im folgenden Beispiel gezeigte Format verwenden:
```
arn:aws:iam::acct-id:role/EMR_EC2_DefaultRole
```
Die *acct-id* kann sich von der AWS Glue-Konto-ID unterscheiden. Dies ermöglicht den Zugriff von EMR-Clustern in verschiedenen Konten aus. Sie können mehrere Principals angeben, von denen jeder aus einem anderen Konto stammt.
## Überlegungen zur Verwendung von AWS Glue Data Catalog
Beachten Sie die folgenden Punkte, wenn Sie AWS Glue Data Catalog als Apache Hive-Metastore mit Spark verwenden:
+ Das Vorhandensein einer Standarddatenbank ohne Speicherort-URI sorgt für Fehler beim Erstellen einer Tabelle. Um dieses Problem zu umgehen, verwenden Sie die `LOCATION`-Klausel, um den Bucket-Speicherort anzugeben, z. B. `s3://amzn-s3-demo-bucket1`, wenn Sie `CREATE TABLE` verwenden. Alternativ können Sie auch Tabellen in einer anderen Datenbank als der Standarddatenbank erstellen.
+ Das Umbenennen von Tabellen in AWS Glue wird nicht unterstützt.
+ Wenn Sie eine Hive-Tabelle erstellen, ohne eine `LOCATION` anzugeben, werden die Tabellendaten an dem in der Eigenschaft `hive.metastore.warehouse.dir` angegebenen Ort gespeichert. Standardmäßig ist dies ein Speicherort in HDFS. Wenn ein anderer Cluster auf die Tabelle zugreifen muss, schlägt er fehl, sofern er nicht über ausreichende Berechtigungen für den Cluster verfügt, der die Tabelle erstellt hat. Da HDFS-Speicher vorübergehend ist, gehen außerdem die Tabellendaten verloren, wenn der Cluster beendet wird, und die Tabelle muss neu erstellt werden. Wir empfehlen, dass Sie `LOCATION` in Amazon S3 a angeben, wenn Sie eine Hive-Tabelle mit AWS Glue erstellen. Alternativ können Sie die `hive-site`-Konfigurationsklassifizierung verwenden, um einen Speicherort in Amazon S3 für `hive.metastore.warehouse.dir` anzugeben, der für alle Hive-Tabellen gilt. Wenn eine Tabelle an einem HDFS-Speicherort erstellt wurde und der Cluster, der sie erstellt hat, noch läuft, können Sie den Tabellenspeicherort von AWS Glue aus auf Amazon S3 aktualisieren. Weitere Informationen finden Sie unter [Arbeiten mit Tabellen auf der AWS Glue-Konsole](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html) im *AWS Glue-Entwicklerhandbuch*.
+ Partitionswerte, die Anführungszeichen und Apostrophe enthalten, werden nicht unterstützt, zum Beispiel `PARTITION (owner="Doe's").`
+ [Spaltenstatistiken](https://cwiki.apache.org/confluence/display/Hive/StatsDev#StatsDev-ColumnStatistics) werden für emr-5.31.0 und höher unterstützt.
+ Die Verwendung der [Hive-Autorisierung](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Authorization) wird nicht unterstützt. Als Alternative sollten Sie die Verwendung [ressourcenbasierter Richtlinien für AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-resource-policies.html) in Betracht ziehen. Weitere Informationen finden Sie unter [Verwenden von ressourcenbasierten Richtlinien für Amazon EMR Access to AWS Glue](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles-glue.html) Data Catalog.
Beachten Sie Folgendes, wenn Sie AWS Glue Data Catalog als Apache Iceberg REST-Katalog mit Spark verwenden:
+ Wenn Sie den Spark-Sitzungskatalog mit Iceberg verwenden, der unter beschrieben ist[Konfigurationsunterschiede bei der Verwendung von Iceberg versus SparkCatalog SparkSessionCatalog](emr-iceberg-use-spark-cluster.md#emr-iceberg-spark-catalog), müssen Sie zusätzlich zur Konfiguration des AWS Glue-Datenkatalogs als Apache Hive-Metastore den AWS Glue-Datenkatalog als Apache Iceberg-REST-Katalog konfigurieren.
+ Der IRC-Endpunkt AWS Glue Data Catalog unterstützt nur das Amazon SigV4-Authentifizierungsschema. OAuth wird nicht unterstützt. OAuth Benutzer verwenden bitte IAM Identity Center, um den Zugriff zu konfigurieren. Weitere Informationen finden Sie unter [Verbindung von Lake Formation mit dem IAM Identity Center](https://docs.aws.amazon.com/lake-formation/latest/dg/connect-lf-identity-center.html).
+ Der AWS Glue Iceberg REST-Katalog unterstützt nicht alle Operationen in Open Source.
# Arbeiten mit einer Hierarchie mit mehreren Katalogen in AWS Glue Data Catalog mit Spark auf Amazon EMR
Sie können Ihren Amazon EMR-Cluster registrieren, um auf den AWS Glue-Datenkatalog zuzugreifen, der Tabellen und andere Katalogressourcen verschiedenen Verbrauchern zur Verfügung stellt. AWS Glue Data Catalog unterstützt eine Hierarchie mit mehreren Katalogen, die Ihre Daten über Amazon S3 S3-Datenseen hinweg vereinheitlicht. Es bietet außerdem sowohl eine Hive-Metastore-API als auch eine Open-Source-Apache Iceberg-REST-API für den Zugriff auf die Daten. Diese Funktionen sind für Amazon EMR und andere Dienste wie Amazon Amazon Athena Redshift verfügbar.
## Wie sind die Katalogressourcen organisiert
Wenn Sie Ressourcen im AWS Glue-Datenkatalog erstellen, können Sie von jeder SQL-Engine aus darauf zugreifen, die die Apache Iceberg REST-API oder den Hive-Metastore unterstützt. AWS Lake Formation verwaltet die Genehmigungen.
In AWS Glue Data Catalog sind Daten in einer logischen Hierarchie von Katalogen, Datenbanken und Tabellen organisiert:
+ **Katalog** — Ein logischer Container, der Objekte aus einem Datenspeicher wie Schemas oder Tabellen enthält.
+ **Katalog zum Speichern von Redshift Managed Storage (RMS) -Tabellen** — Wenn Sie Kataloge zum Speichern von RMS-Tabellen verwalten, können Sie mit Iceberg auf diese Tabellen zugreifen.
+ **Datenbank** — Organisiert Datenobjekte wie Tabellen und Ansichten in einem Katalog.
+ **Tabellen und Ansichten** — Datenobjekte in einer Datenbank, die eine Abstraktionsebene mit einem verständlichen Schema bieten. Sie bieten eine Ebene für den Zugriff auf zugrunde liegende Daten, die in verschiedenen Formaten und an verschiedenen Orten vorliegen können.
## Konfiguration eines Datenkatalogs für die Verwendung mit Amazon EMR
Zu Beginn konfigurieren Sie den Katalog so, dass er die Amazon EMR-Tools unterstützt. Der AWS Glue-Datenkatalog bietet Hive-Metastore-Kompatibilität und Iceberg-REST-Kompatibilität. APIs
**Konfiguration von Amazon EMR mit einem Hive-Metastore**
Informationen zur Einrichtung finden Sie unter [Unterstützung des AWS Glue-Datenkatalogs für Spark-Jobs](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-data-catalog-hive.html) im AWS Glue-Benutzerhandbuch. In diesem Thema wird beschrieben, wie der AWS Glue-Datenkatalog als Hive-Metastore konfiguriert und als Endpunkt verfügbar gemacht wird. Darüber hinaus ist eine Amazon EMR-Dokumentation verfügbar, die Ihnen unter [Verwenden des AWS Glue-Datenkatalogs als Apache Hive-Metastore für Spark zeigt, wie Sie AWS Glue Data Catalog als Spark-Metastore](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-glue.html) angeben.
## Berechtigungen für den Zugriff auf Ressourcen im AWS Glue Data Catalog
In diesem Abschnitt werden die IAM-Richtlinienanforderungen für die Verwendung von Amazon EMR-Tools mit Katalogdaten beschrieben. Nachdem Sie Ihren Cluster beim AWS Glue-Datenkatalog registriert haben, benötigen Sie die folgenden Berechtigungen, um die Erstellung und Änderungen des anschließend erstellten Datenkatalogs zu ermitteln:
+ **kleben: GetCatalog**
+ **kleben: GetCatalogs**
+ **Sätze: AssumeRole**
+ **sts: TagSession**
+ **sts: SetContext**
+ **sts: SetSourceIdentity**
In den meisten Fällen empfehlen wir, bei der Zuweisung von Berechtigungen eine IAM-Rolle zu erstellen und ihr Berechtigungen zuzuweisen.
Um Katalogdaten abzufragen, müssen Sie außerdem die Berechtigungen für den Datenkatalog mithilfe von festlegen. AWS Lake Formation Weitere Informationen zum Festlegen von Berechtigungen für Datenkataloge finden Sie unter [Erteilen und Widerrufen von Berechtigungen für Datenkatalogressourcen](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html). AWS Lake Formation
Nachdem Sie Ihren Cluster erstellt und konfiguriert und die Berechtigungen für Ihre Katalogobjekte festgelegt haben, können Sie Jobs zum Abfragen und Verarbeiten von Daten einreichen.
## Konfigurieren Sie Spark für den Zugriff auf eine Hierarchie mit mehreren Katalogen in AWS Glue Data Catalog
Mit EMR 7.5 können Sie Spark so konfigurieren, dass die Multi-Katalog-Hierarchie von AWS Glue verwendet wird. Eine Hierarchie mit mehreren Katalogen ermöglicht Ihnen:
+ Bringen Sie Ihre Redshift Managed Storage (RMS) -Daten wie Tabellen, Ansichten und materialisierte Ansichten aus bestehenden Amazon Redshift Data Warehouses in Glue Data Catalog. AWS Sie können diese Objekte mit EMR auf EC2 und EMR Serverless abfragen.
+ Erstellen Sie RMS-Kataloge, AWS Glue Data Catalog und speichern Sie Daten in RMS mit ZeroETL und fragen Sie die Daten mit Iceberg-kompatiblen Abfrage-Engines ab.
+ Erstellen Sie verwaltete Iceberg-Tabellen in AWS Glue Data Catalog mit umfassendem Speichermanagement, das Komprimierung, Snapshots und Aufbewahrung umfasst.
### Verbindung zu mehreren Katalogen herstellen, wenn Sie eine Spark-Sitzung initialisieren
Die folgenden Beispiele zeigen, wie Sie interaktive Spark-Shell, Spark Submit oder Amazon EMR Notebooks verwenden können, um mit der Multi-Katalog-Hierarchie von AWS Glue 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 durch`spark-shell`. `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.catalog.my_catalog.glue.id=Glue RMS catalog ID \
--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 Spark 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.catalog.my_catalog.glue.id=Glue RMS catalog ID \
--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.glue.id":"Glue RMS catalog ID",
"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 eine Spark-Sitzung mit der CLI zu initialisieren. 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.glue.id":"Glue RMS catalog ID",
"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"
}
}
]
```
------
#### Initialisieren Sie eine Spark-Sitzung mit Redshift Managed Storage mit AWS Glue Data Catalog
Der folgende Beispielbefehl initialisiert eine Spark-Sitzung mit dem AWS Glue-Datenkatalog.
```
spark-sql \
--conf spark.sql.catalog.rms=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.rms.type=glue \
--conf spark.sql.catalog.rms.glue.id=Glue RMS catalog ID \
--conf spark.sql.defaultCatalog=rms
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Das folgende Beispiel initialisiert eine Spark-Sitzung mithilfe der Iceberg REST API und Redshift Managed Storage with AWS Glue Data Catalog.
```
spark-sql \
--conf spark.sql.catalog.rms=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.rms.type=rest \
--conf spark.sql.catalog.rms.warehouse=glue RMS catalog ID \
--conf spark.sql.catalog.rms.uri=Glue endpoint URI/iceberg \
--conf spark.sql.catalog.rms.rest.sigv4-enabled=true \
--conf spark.sql.catalog.rms.rest.signing-name=glue \
--conf spark.sql.defaultCatalog=rms \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Weitere Informationen zur Verwendung einer AWS Glue-Hierarchie mit mehreren Katalogen mit Spark Iceberg finden Sie unter [Verwenden eines Iceberg-Clusters](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-iceberg-use-spark-cluster.html) mit Spark.
## Überlegungen und Einschränkungen für eine Konfiguration mit mehreren Katalogen
+ Die Verwendung einer Hierarchie mit mehreren Katalogen mit Apache Hive Metastore wird nicht unterstützt.
+ Die Verwendung einer Hierarchie mit mehreren Katalogen mit Apache Iceberg unterstützt bei Verwendung keinen Fallback auf Apache Hive Metastore. `SparkSessionCatalog`
+ EMR auf EC2-Clustern mit Runtime-Rolle unterstützt keine Hierarchie mit mehreren Katalogen.
+ EMR auf EC2-Clustern, die aktiviert sind, unterstützen AWS Lake Formation keine Hierarchie mit mehreren Katalogen.
# Konfigurieren von Spark
Sie können [Spark in Amazon EMR](https://aws.amazon.com/elasticmapreduce/details/spark/) mithilfe von Konfigurationsklassifizierungen konfigurieren. Weitere Informationen über Konfigurationsklassifizierungen finden Sie unter [Anwendungen konfigurieren](emr-configure-apps.md).
Zu den Konfigurationsklassifizierungen für Spark in Amazon EMR gehören die folgenden:
+ **`spark`** – Setzt die `maximizeResourceAllocation`-Eigenschaft auf „wahr“ oder „falsch“. Wenn „wahr“, konfiguriert Amazon EMR die `spark-defaults`-Eigenschaften automatisch auf der Grundlage der Cluster-Hardwarekonfiguration. Weitere Informationen finden Sie unter [Verwenden von `maximizeResourceAllocation`](#emr-spark-maximizeresourceallocation).
+ **`spark-defaults`** – Setzt Werte in der `spark-defaults.conf`-Datei. Weitere Informationen finden Sie unter [Spark-Konfiguration](https://spark.apache.org/docs/latest/configuration.html) in der Spark-Dokumentation.
+ **`spark-env`** – Setzt Werte in der `spark-env.sh`-Datei. Weiter Informationen finden Sie unter [Umgebungsvariablen](https://spark.apache.org/docs/latest/configuration.html#environment-variables) in der Spark-Dokumentation.
+ **`spark-hive-site`** – Legt Werte in der `hive-site.xml` für Spark fest.
+ **`spark-log4j`** – (Amazon-EMR-Versionen 6.7.x und niedriger) Legt Werte in der `log4j.properties`-Datei fest. Weitere Informationen finden Sie in der [log4j.properties.template](https://github.com/apache/spark/blob/branch-3.2/conf/log4j.properties.template)-Datei auf Github.
+ **`spark-log4j2`** – (Amazon-EMR-Version 6.8.0 und höher) Legt Werte in der `log4j2.properties`-Datei fest. Weitere Informationen finden Sie in der [log4j2.properties.template](https://github.com/apache/spark/blob/v3.3.0/conf/log4j2.properties.template)-Datei auf Github.
+ **`spark-metrics`** – Setzt Werte in der `metrics.properties`-Datei. Einstellungen und weitere Informationen finden Sie in der [metrics.properties.template](https://github.com/apache/spark/blob/master/conf/metrics.properties.template)-Datei auf GitHub und unter [Metrics](https://spark.apache.org/docs/latest/monitoring.html#metrics) in der Spark-Dokumentation.
**Anmerkung**
Wenn Sie Spark-Workloads von einer anderen Plattform zu Amazon EMR migrieren, empfehlen wir Ihnen, Ihre Workloads mit den [Durch Amazon EMR festgelegte Spark-Standardeinstellungen](#spark-defaults) zu testen, bevor Sie benutzerdefinierte Konfigurationen hinzufügen. Die meisten Kunden sehen mit unseren Standardeinstellungen eine verbesserte Leistung.
**Topics**
+ [Durch Amazon EMR festgelegte Spark-Standardeinstellungen](#spark-defaults)
+ [Konfiguration der Spark-Garbage-Collection auf Amazon EMR 6.1.0](#spark-gc-config)
+ [Verwenden von `maximizeResourceAllocation`](#emr-spark-maximizeresourceallocation)
+ [Verhalten der Außerbetriebnahme von Knoten konfigurieren](#spark-decommissioning)
+ [ThriftServer Spark-Umgebungsvariable](#spark-thriftserver)
+ [Ändern von Spark-Standardeinstellungen](#spark-change-defaults)
+ [Migration von Apache Log4j 1.x zu Log4j 2.x](#spark-migrate-logj42)
## Durch Amazon EMR festgelegte Spark-Standardeinstellungen
Die folgende Tabelle zeigt, wie Amazon EMR Standardwerte in `spark-defaults` setzt, die sich auf Anwendunen auswirken.
**Durch Amazon EMR festgelegte Spark-Standardeinstellungen**
| Einstellung | Description | Standardwert |
| --- | --- | --- |
| spark.executor.memory | Die pro Executor-Prozess zu verwendende Größe des Speichers. Zum Beispiel: `1g`, `2g`. | Diese Einstellung wird durch die Core- und Aufgaben-Instance-Typen im Cluster bestimmt. |
| spark.executor.cores | Die für jeden Executor zu verwendende Anzahl der Kerne. | Diese Einstellung wird durch die Core- und Aufgaben-Instance-Typen im Cluster bestimmt. |
| spark.dynamicAllocation.enabled | Wenn „wahr“, verwenden Sie die dynamische Ressourcenzuteilung, um die Anzahl der bei einer Anwendung registrierten Executoren basierend auf dem Workload nach oben oder unten zu skalieren. | `true` (mit Amazon EMR 4.4.0 und höher) Spark Shuffle Service wird automatisch von Amazon EMR konfiguriert. |
| spark.sql.hive.advancedPartitionPredicatePushdown.enabled | Wenn der Wert „wahr“ ist, ist der erweiterte Pushdown von Partitionsprädikaten in den Hive-Metastore aktiviert. | true |
| spark.sql.hive.stringLikePartitionPredicatePushdown.enabled | Verschiebt und filtert `startsWith`, `contains` und `endsWith` nach unten in den Hive-Metastore. Glue unterstützt das Prädikat-Pushdown für `startsWith`, `contains` oder `endsWith` nicht. Wenn Sie Glue Metastore verwenden und aufgrund des Prädikat-Pushdowns für diese Funktionen auf Fehler stoßen, setzen Sie diese Konfiguration auf `false`. | true |
## Konfiguration der Spark-Garbage-Collection auf Amazon EMR 6.1.0
Das Einrichten von benutzerdefinierten Garbage-Collection-Konfigurationen mit `spark.driver.extraJavaOptions` und `spark.executor.extraJavaOptions` führt dazu, dass der Treiber- oder Ausführer-Start mit Amazon EMR 6.1 fehlschlägt, weil eine Konfiguration der Garbage-Collection-Konfiguration mit Amazon EMR 6.1.0 in Konflikt steht. Für Amazon EMR 6.1.0 wird die Standard-Garbage-Collection über `spark.driver.defaultJavaOptions` und `spark.executor.defaultJavaOptions` festgelegt. Diese Konfiguration gilt nur für Amazon EMR 6.1.0. JVM-Optionen, die nichts mit der Garbage-Collection zu tun haben, wie z. B. die für die Konfiguration von Protokollierung (`-verbose:class`), können dennoch durch `extraJavaOptions` festgelegt werden. Weitere Informationen finden Sie unter [Spark-Anwendungs-Eigenschaften.](https://spark.apache.org/docs/latest/configuration.html#application-properties)
## Verwenden von `maximizeResourceAllocation`
Um Ihre Executors so zu konfigurieren, dass sie auf jedem Knoten in einem Cluster die maximal möglichen Ressourcen nutzen, setzen Sie in Ihrer `spark`-Konfigurationsklassifizierung `maximizeResourceAllocation` auf `true`. `maximizeResourceAllocation` ist spezifisch für Amazon EMR. Wenn Sie `maximizeResourceAllocation` aktivieren, berechnet Amazon EMR die maximal verfügbaren Rechen- und Speicherressourcen für einen Executor auf einer Instance in der Core-Instance-Gruppe. Anschließend werden die entsprechenden `spark-defaults`-Einstellungen auf der Grundlage der berechneten Höchstwerte festgelegt.
Amazon EMR berechnet die maximalen Rechen- und Speicherressourcen, die für einen Executor verfügbar sind, basierend auf einem Instance-Typ aus der Core-Instance-Flotte. Da jede Instance-Flotte unterschiedliche Instance-Typen und Größen innerhalb einer Flotte haben kann, ist die von Amazon EMR verwendete Executor-Konfiguration möglicherweise nicht die beste für Ihre Cluster. Daher empfehlen wir nicht, die Standardeinstellungen zu verwenden, wenn Sie die maximale Ressourcenzuweisung verwenden. Konfigurieren Sie benutzerdefinierte Einstellungen für Ihre Instance-Flottencluster.
**Anmerkung**
Sie sollten die `maximizeResourceAllocation` Option nicht für Cluster mit anderen verteilten Anwendungen wie verwenden HBase. Amazon EMR verwendet benutzerdefinierte YARN-Konfigurationen für verteilte Anwendungen, die zu Konflikten mit `maximizeResourceAllocation` führen und zum Scheitern von Spark-Anwendungen führen können.
Im Folgenden finden Sie ein Beispiel für eine Spark-Konfigurationsklassifizierung mit der `maximizeResourceAllocation`-Einstellung auf `true`.
```
[
{
"Classification": "spark",
"Properties": {
"maximizeResourceAllocation": "true"
}
}
]
```
**Einstellungen, die in `spark-defaults` konfiguriert sind, wenn `maximizeResourceAllocation` aktiviert ist**
| Einstellung | Description | Wert |
| --- | --- | --- |
| spark.default.parallelism | Die Standardanzahl von Partitionen wird von Transformationen wie Join, und Parallelize RDDs zurückgegeben reduceByKey, wenn sie nicht vom Benutzer festgelegt wurden. | Die zweifache Anzahl von CPU-Kernen für YARN-Container. |
| spark.driver.memory | Speichermenge, die für den Treiberprozess verwendet werden soll, d. h. wo SparkContext er initialisiert wird. (zum Beispiel 1 g, 2 g). | Die Einstellung wird auf der Grundlage der Instance-Typen im Cluster konfiguriert. Da die Spark-Treiberanwendung jedoch entweder in der Primär-Instance oder in einer der Core-Instances ausgeführt werden kann (z. B. im YARN-Client- und -Cluster-Modus), wird sie auf der Grundlage des kleineren Instance-Typs in diesen beiden Instance-Gruppen festgelegt. |
| spark.executor.memory | Die pro Executor-Prozess zu verwendende Größe des Speichers (beispielsweise 1g, 2g). | Die Einstellung wird auf der Grundlage der Core- und der Aufgaben-Instance-Typen im Cluster konfiguriert. |
| spark.executor.cores | Die für jeden Executor zu verwendende Anzahl der Kerne. | Die Einstellung wird auf der Grundlage der Core- und der Aufgaben-Instance-Typen im Cluster konfiguriert. |
| spark.executor.instances | Die Anzahl der Executor. | Die Einstellung wird auf der Grundlage der Core- und der Aufgaben-Instance-Typen im Cluster konfiguriert. Festgelegt, wenn `spark.dynamicAllocation.enabled` nicht gleichzeitig explizit auf "true" festgelegt wurde. |
## Verhalten der Außerbetriebnahme von Knoten konfigurieren
Bei der Verwendung von Amazon-EMR-Version 5.9.0 oder höher, enthält Spark für Amzon EMR eine Reihe von Features, um sicherzustellen, dass Spark die Knotenbeendigung infolge einer manuellen Größenänderung oder einer Anforderung einer Auto-Scaling-Richtlinie zuverlässig ausführt. Amazon EMR implementiert einen Sperr-Mechanismus in Spark, der dem Außerbetriebnahme-Mechanismus von YARN übergeordnet ist. Dieser Mechanismus hilft sicherzustellen, dass keine neuen Aufgaben in einem Knoten geplant werden, der außer Betrieb genommen wird. Gleichzeitig werden bereits begonnene Aufgaben abgeschlossen. Darüber hinaus gibt es Funktionen, mit deren Hilfe Spark-Aufgaben schneller wiederhergestellt werden, wenn Shuffle-Blöcke bei der Beendigung eines Knotens verloren gehen. Der Neuberechnungsprozess wird früher ausgelöst und ist optimiert, um eine schnellere Neuberechnung mit weniger Stufenwiederholungen zu ermöglichen. Außerdem kann vermieden werden, dass Aufträge infolge von fehlenden Shuffle-Blöcken fehlschlagen.
**Wichtig**
Die Einstellung `spark.decommissioning.timeout.threshold` wurde in Amazon-EMR-Version 5.11.0 hinzugefügt, um die Ausfallsicherheit von Spark zu verbessern, wenn Sie Spot Instances verwenden. Wenn in früheren Versionen ein Knoten eine Spot Instance verwendet und die Instance aufgrund des Bid-Preises beendet wird, kann Spark die Beendigung möglicherweise nicht zuverlässig abschliessen. Aufträge können fehlschlagen und Shuffle-Neuberechnungen können eine geraume Zeit in Anspruch nehmen. Aus diesem Grund empfehlen wir die Nutzung von Version 5.11.0 oder höher, wenn Sie Spot Instances verwenden.
**Einstellungen für die Außerbetriebnahme von Spark Node**
| Einstellung | Description | Standardwert |
| --- | --- | --- |
| `spark.blacklist.decommissioning.enabled` | Wenn die Einstellung auf `true` gesetzt ist, sperrt Spark die Knoten, die sich in YARN im `decommissioning`-Zustand befinden. Spark plant keine neuen Aufgaben auf Executors aus, die auf dem betreffenden Knoten ausgeführt werden. Bereits begonnene Aufgaben werden abgeschlossen. | `true` |
| `spark.blacklist.decommissioning.timeout` | Die Zeitspanne, wie lange ein Knoten im Status `decommissioning` gesperrt wird. Standardmäßig ist dieser Wert auf eine Stunde festgelegt. Dies ist auch die Standardeinstellung für `yarn.resourcemanager.decommissioning.timeout`. Um sicherzustellen, dass ein Knoten über den gesamten Außerbetriebnahme-Zeitraum gesperrt wird, setzen Sie diesen Wert größer oder gleich `yarn.resourcemanager.decommissioning.timeout`. Nachdem die Frist für die Außerbetriebnahme abgelaufen ist, wird der Knoten in den Zustand `decommissioned` überführt, und Amazon EMR kann die EC2-Instance des Knotens beenden. Wenn noch Aufgaben ausgeführt werden, nachdem die Zeitbeschränkung abgelaufen ist, gehen diese verloren oder werden abgebrochen und auf Executors, die auf anderen Knoten ausgeführt werden, verschoben. | `1h` |
| `spark.decommissioning.timeout.threshold` | Verfügbar in Amazon-EMR-Version 5.11.0 oder höher. In Sekunden angegeben. Wenn ein Knoten in den Status „Außerbetriebnahme“ übergeht und der Host ihn innerhalb der durch diesen Wert festgelegten Frist außer Betrieb nimmt, sperrt Amazon EMR den Knoten nicht nur, sondern bereinigt auch den Host-Status (wie in `spark.resourceManager.cleanupExpiredHost` angegeben), ohne darauf zu warten, dass der Knoten in den Status „Außerbetriebnahme“ übergeht. Auf diese Weise kann Spark das Beenden von Spot-Instances besser verarbeiten, weil Spot-Instances innerhalb eines Timeouts von 20 Sekunden außer Betrieb genommen werden, unabhängig von dem Wert von `yarn.resourcemager.decommissioning.timeout`, sodass andere Knoten möglicherweise nicht genügend Zeit haben, Shuffle-Dateien zu lesen. | `20s` |
| `spark.resourceManager.cleanupExpiredHost` | Wenn die Einstellung auf `true` gesetzt ist, löscht Spark alle zwischengespeicherten Daten und Shuffle-Blöcke, die in Executors in Knoten gespeichert sind, die sich im Zustand `decommissioned` befinden. Dadurch wird der Wiederherstellungsprozess beschleunigt. | `true` |
| `spark.stage.attempt.ignoreOnDecommissionFetchFailure` | Wenn die Einstellung auf `true` gesetzt ist, wird verhindert, dass in Spark Stufen und letztendlich Aufträge wegen zu vieler Abrufe von außer Betrieb genommenen Knoten fehlschlagen. Fehler beim Abrufen von Shuffle-Blöcken von einem Knoten im Zustand `decommissioned` werden nicht zu der maximal zulässigen Anzahl von aufeinander folgenden Abruffehlern hinzugezählt. | true |
## ThriftServer Spark-Umgebungsvariable
Spark legt die Hive-Thrift-Server-Port-Umgebungsvariable `HIVE_SERVER2_THRIFT_PORT` auf "10001" fest.
## Ändern von Spark-Standardeinstellungen
Sie ändern die Standardwerte in `spark-defaults.conf` mit der Konfigurationsklassifizierung`spark-defaults` oder der Einstellung `maximizeResourceAllocation` in der Konfigurationsklassifizierung `spark`.
In den folgenden Verfahren wird gezeigt, wie Sie Einstellungen mithilfe der CLI oder der Konsole ändern.
**Erstellen Sie einen Cluster mithilfe der CLI mit der Einstellung „spark.executor.memory“ auf „2G“ wie folgt**
+ Erstellen Sie einen Cluster mit installiertem Spark und `spark.executor.memory` auf 2G gesetzt, indem Sie den folgenden Befehl eingeben, der auf die Datei `myConfig.json` verweist, die in Amazon S3 gespeichert ist.
```
aws emr create-cluster --release-label emr-7.12.0 --applications Name=Spark \
--instance-type m5.xlarge --instance-count 2 --service-role EMR_DefaultRole_V2 --ec2-attributes InstanceProfile=EMR_EC2_DefaultRole --configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/myfolder/myConfig.json
```
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
`myConfig.json`:
```
[
{
"Classification": "spark-defaults",
"Properties": {
"spark.executor.memory": "2G"
}
}
]
```
**Erstellen Sie einen Clustermithilfe der Konsole mit der Einstellung „spark.executor.memory“ auf „2G“ wie folgt**
1. Navigieren Sie zur neuen Amazon-EMR-Konsole und wählen Sie in der Seitennavigation die Option **Zur alten Konsole wechseln** aus. Weitere Informationen darüber, was Sie erwartet, wenn Sie zur alten Konsole wechseln, finden Sie unter [Verwenden der alten Konsole](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Wählen Sie **Create Cluster (Cluster erstellen)** und **Go to advanced options (Zu erweiterten Optionen)** aus.
1. Wählen Sie **Spark** aus.
1. Lassen Sie unter **Edit software settings (Softwareeinstellungen bearbeiten)** die Option **Enter configuration (Konfiguration eingeben)** ausgewählt und nehmen Sie folgende Konfiguration vor:
```
classification=spark-defaults,properties=[spark.executor.memory=2G]
```
1. Wählen Sie andere Optionen aus, dann **** und anschließend **Create cluster (Cluster erstellen)**.
**Zum Einstellen maximizeResourceAllocation**
+ Erstellen Sie einen Cluster, auf dem Spark installiert und auf true `maximizeResourceAllocation` gesetzt ist AWS CLI, indem Sie die in Amazon S3 gespeicherte Datei referenzieren. `myConfig.json`
```
aws emr create-cluster --release-label emr-7.12.0 --applications Name=Spark \
--instance-type m5.xlarge --instance-count 2 --service-role EMR_DefaultRole_V2 --ec2-attributes InstanceProfile=EMR_EC2_DefaultRole --configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/myfolder/myConfig.json
```
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
`myConfig.json`:
```
[
{
"Classification": "spark",
"Properties": {
"maximizeResourceAllocation": "true"
}
}
]
```
**Anmerkung**
Ab Amazon-EMR-Version 5.21.0 können Sie Cluster-Konfigurationen überschreiben und zusätzliche Konfigurationsklassifikationen für jede Instance-Gruppe in einem ausgeführten Cluster angeben. Dazu verwenden Sie die Amazon EMR-Konsole, das AWS Command Line Interface (AWS CLI) oder das AWS SDK. Weitere Informationen finden Sie unter [Angeben einer Konfiguration für eine Instance-Gruppe in einem aktiven Cluster](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps-running-cluster.html).
## Migration von Apache Log4j 1.x zu Log4j 2.x
[Apache-Spark-Versionen](https://aws.amazon.com/emr/features/spark/) 3.2.x und frühere Versionen verwenden den älteren Apache Log4j 1.x und die `log4j.properties`-Datei, um Log4j in Spark-Prozessen zu konfigurieren. Apache-Spark-Versionen 3.3.0 und höher verwenden Apache Log4j 2.x und die Datei `log4j2.properties`, um Log4j in Spark-Prozessen zu konfigurieren.
Wenn Sie Apache Spark Log4j mit einer Amazon-EMR-Version vor 6.8.0 konfiguriert haben, müssen Sie die alte `spark-log4j`-Konfigurationsklassifizierung entfernen und zur `spark-log4j2`-Konfigurationsklassifizierung und zum Schlüsselformat migrieren, bevor Sie auf Amazon EMR 6.8.0 oder höher aktualisieren können. Die `spark-log4j`-Legacy-Klassifizierung führt dazu, dass die Clustererstellung in Amazon-EMR-Versionen 6.8.0 und höher mit einem `ValidationException`-Fehler fehlschlägt. Ein Fehler im Zusammenhang mit der Log4j-Inkompatibilität wird Ihnen nicht in Rechnung gestellt. Sie müssen jedoch die Klassifizierung für die veraltete `spark-log4j`-Konfiguration entfernen, um fortzufahren.
Weitere Informationen zur Migration von Apache Log4j 1.x zu Log4j 2.x finden Sie im [Apache Log4j Migration Benutzerhandbuch](https://logging.apache.org/log4j/2.x/manual/migration.html) und im [Spark Log4j 2 Template](https://github.com/apache/spark/blob/master/conf/log4j2.properties.template) auf Github.
**Anmerkung**
Bei Amazon EMR verwendet Apache Spark eine `log4j2.properties`-Datei anstelle der im [Apache-Log4j-Migration-Benutzerhandbuch](https://logging.apache.org/log4j/2.x/manual/migration.html) beschriebenen .xml-Datei. Außerdem empfehlen wir nicht, die Log4j-1.x-Bridge-Methode für die Konvertierung nach Log4j 2.x zu verwenden.
# Was ist der Apache Spark Troubleshooting Agent für Amazon EMR
## Einführung
Der Apache Spark Troubleshooting Agent für Amazon EMR ist eine Konversations-KI-Funktion, die die Fehlerbehebung von Apache Spark-Anwendungen auf Amazon EMR, AWS Glue und Amazon Notebooks vereinfacht. SageMaker Die herkömmliche Spark-Fehlerbehebung erfordert eine umfangreiche manuelle Analyse von Protokollen, Leistungskennzahlen und Fehlermustern, um die Grundursachen zu identifizieren und den Code zu beheben. Der Agent vereinfacht diesen Prozess durch Eingabeaufforderungen in natürlicher Sprache, automatisierte Workload-Analysen und intelligente Codeempfehlungen.
Sie können den Agenten zur Behebung von Fehlern PySpark und Fehlern bei Scala-Anwendungen verwenden. Der Agent analysiert Ihre fehlgeschlagenen Jobs, identifiziert Leistungsengpässe und gibt umsetzbare Empfehlungen und Codekorrekturen, während Sie gleichzeitig die volle Kontrolle über Implementierungsentscheidungen haben.
**Anmerkung**
Der Apache Spark Troubleshooting Agent ist ohne zusätzliche Kosten als Teil von Amazon EMR erhältlich. Der Agent bietet nur Analysen und Empfehlungen. Sie zahlen nur für die Amazon EMR-Ressourcen, die Sie verwenden, wenn Sie Ihre Anwendungen ausführen, um alle empfohlenen Korrekturen zu überprüfen.
## Übersicht über die Architektur
Der Troubleshooting-Agent besteht aus drei Hauptkomponenten: einem MCP-kompatiblen KI-Assistenten in Ihrer Entwicklungsumgebung zur Interaktion, dem [MCP-Proxy](https://github.com/aws/mcp-proxy-for-aws), der AWS die sichere Kommunikation und Authentifizierung zwischen Ihrem Client und Ihren AWS Services übernimmt, und dem Amazon SageMaker Unified Studio Remote MCP Server`(preview)`, der spezielle Spark-Tools zur Fehlerbehebung für Amazon EMR, AWS Glue und Amazon Notebooks bereitstellt. SageMaker Dieses Diagramm zeigt, wie Sie über Ihren KI-Assistenten mit dem Amazon SageMaker Unified Studio Remote MCP Server interagieren.
![\[Agentenarchitektur zur Fehlerbehebung bei Spark.\]](http://docs.aws.amazon.com/de_de/emr/latest/ReleaseGuide/images/spark-troubleshooting-agent-architecture.png)
Der KI-Assistent orchestriert die Fehlerbehebung mithilfe spezieller Tools, die vom MCP-Server bereitgestellt werden, und folgt dabei den folgenden Schritten:
+ **Funktionsextraktion und Kontexterstellung:** Der Agent sammelt und analysiert automatisch Telemetriedaten aus Ihrer Spark-Anwendung, einschließlich der Spark History Server-Protokolle, Konfigurationseinstellungen und Fehlerverfolgungen. Er extrahiert wichtige Leistungskennzahlen, Ressourcennutzungsmuster und Fehlersignaturen, um ein umfassendes Kontextprofil für die intelligente Fehlerbehebung zu erstellen.
+ **GenAI Root Cause Analyzer und Recommendation Engine:** Der Agent nutzt KI-Modelle und die Spark-Wissensdatenbank, um extrahierte Funktionen zu korrelieren und die Hauptursachen von Leistungsproblemen oder Ausfällen zu identifizieren. Es bietet diagnostische Erkenntnisse und Analysen darüber, was bei der Ausführung Ihrer Spark-Anwendung schief gelaufen ist.
+ **GenAI Spark-Code-Empfehlung:** Auf der Grundlage der Ursachenanalyse aus dem vorherigen Schritt analysiert der Agent Ihre vorhandenen Codemuster und identifiziert ineffiziente Operationen, bei denen Codekorrekturen für Anwendungsfehler erforderlich sind. Er bietet umsetzbare Empfehlungen, darunter spezifische Codeänderungen, Konfigurationsanpassungen und architektonische Verbesserungen anhand konkreter Beispiele.
**Topics**
+ [Einführung](#spark-troubleshooting-agent-intro)
+ [Übersicht über die Architektur](#spark-troubleshooting-agent-architecture)
+ [Einrichtung für den Troubleshooting Agent](spark-troubleshooting-agent-setup.md)
+ [Den Troubleshooting Agent verwenden](spark-troubleshooting-using-troubleshooting-agent.md)
+ [Funktionen und Fähigkeiten](spark-troubleshooting-features.md)
+ [Problembehandlung und Fragen und Antworten](spark-troubleshooting-agent-troubleshooting.md)
+ [Der Arbeitsablauf für Spark-Agenten zur Fehlerbehebung im Detail](spark-troubleshooting-agent-workflow.md)
+ [Prompte Beispiele](spark-troubleshooting-agent-prompt-examples.md)
+ [Einrichtung der IAM-Rolle](spark-troubleshooting-agent-iam-setup.md)
+ [Verwenden der Spark-Tools zur Fehlerbehebung](spark-troubleshooting-agent-using-tools.md)
+ [Konfiguration von Schnittstellen-VPC-Endpunkten für Amazon SageMaker Unified Studio MCP](spark-troubleshooting-agent-vpc-endpoints.md)
+ [Regionsübergreifende Verarbeitung für den Apache Spark Troubleshooting Agent](spark-troubleshooting-cross-region-processing.md)
+ [Protokollieren von Amazon SageMaker Unified Studio MCP-Aufrufen mit AWS CloudTrail](spark-troubleshooting-cloudtrail-integration.md)
+ [Serviceverbesserungen für Apache Spark-Agenten](spark-agents-service-improvements.md)
# Einrichtung für den Troubleshooting Agent
**Anmerkung**
Der Apache Spark Troubleshooting Agent verwendet regionsübergreifende Inferenz, um Anfragen in natürlicher Sprache zu verarbeiten und Antworten zu generieren. Weitere Einzelheiten finden Sie unter. [Regionsübergreifende Verarbeitung für den Apache Spark Troubleshooting Agent](spark-troubleshooting-cross-region-processing.md) Der Amazon SageMaker Unified Studio MCP-Server befindet sich in der Vorschauversion und kann sich ändern.
## Voraussetzungen
Bevor wir mit dem Einrichtungsprozess für die Integration mit Kiro CLI beginnen, stellen Sie sicher, dass auf Ihrer Workstation Folgendes installiert ist:
+ [AWS CLI installieren](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Installieren Sie Python 3.10\$1](https://www.python.org/downloads/release/python-3100/)
+ [Installieren Sie den `uv` Paketmanager für [MCP](https://github.com/aws/mcp-proxy-for-aws?tab=readme-ov-file)](https://docs.astral.sh/uv/getting-started/installation/) Proxy für AWS
+ [Installieren Sie Kiro CLI](https://kiro.dev/docs/cli/)
+ AWS Konfiguration lokaler Anmeldeinformationen (über [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html), Umgebungsvariablen oder IAM-Rollen) — für lokale Operationen wie das Hochladen aktualisierter Job-Artefakte für die Ausführung von EMR-Validierungsaufträgen.
## Ressourcen einrichten
Sie können eine AWS CloudFormation Vorlage verwenden, um die Ressource für den MCP-Server einzurichten. Diese Vorlagen sind Beispiele, die Sie entsprechend Ihren Anforderungen anpassen sollten. Die Vorlage erstellt die folgenden Ressourcen für den Problembehandlungsprozess:
1. IAM-Rolle, die über Berechtigungen zum Aufrufen des MCP-Servers und über die erforderlichen Berechtigungen für den Fehlerbehebungsprozess für die ausgewählte Plattform verfügt.
Wählen Sie eine der Schaltflächen **Launch Stack (Stack starten)** in der folgenden Tabelle aus. Dadurch wird der Stack auf der AWS CloudFormation Konsole in der jeweiligen Region gestartet.
| Region | Starten |
| --- | --- |
| US East (Ohio) | [https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| USA Ost (Nord-Virginia) | [https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| USA West (Oregon) | [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Asien-Pazifik (Tokio) | [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (Irland) | [https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Asien-Pazifik (Singapur) | [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Asien-Pazifik (Sydney) | [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Kanada (Zentral) | [https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Südamerika (São Paulo) | [https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (Frankfurt) | [https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (Stockholm) | [https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (London) | [https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (Paris) | [https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Asien-Pazifik (Seoul) | [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Asien-Pazifik (Mumbai) | [https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
Gehen Sie zur Seite „**Stack-Details angeben**“ und geben Sie den **Stack-Namen** ein. Geben Sie zusätzliche Informationen unter **Parameter** ein. Geben Sie die folgenden Informationen ein und fahren Sie mit der Erstellung des Stacks fort.
+ **TroubleshootingRoleName**— Name der IAM-Rolle, die für die Fehlerbehebung erstellt werden soll
+ **Aktivieren EMREC2** — EMR-EC2-Berechtigungen zur Fehlerbehebung aktivieren (Standard: true)
+ **Aktivieren EMRServerless** — Aktiviert EMR-Serverless-Fehlerbehebungsberechtigungen (Standard: true)
+ **EnableGlue**- Aktivieren Glue Glue-Berechtigungen zur Fehlerbehebung (Standard: true)
+ **CloudWatchKmsKeyArn**— (Optional) ARN des vorhandenen KMS-Schlüssels für die CloudWatch Protokollverschlüsselung (nur EMR Serverless, für Standardverschlüsselung leer lassen)
Sie können [die CloudFormation Vorlage](https://github.com/aws-samples/aws-emr-utilities/blob/03c20fece616de23ec0ea5389f0113a5bc65fc3a/utilities/apache-spark-agents/spark-troubleshooting-agent-cloudformation/spark-troubleshooting-mcp-setup.yaml) auch herunterladen und überprüfen, die obigen Optionen angeben und die Vorlage selbst mit CloudFormation CLI-Befehlen starten. Ein Beispiel finden Sie unten:
```
# deploy the stack with CloudFormation CLI commands
aws cloudformation deploy \
--template-file spark-troubleshooting-mcp-setup.yaml \
--stack-name spark-troubleshooting-mcp-setup \
--region \
--capabilities CAPABILITY_NAMED_IAM \
--parameter-overrides \
TroubleshootingRoleName=spark-troubleshooting-role
# retrieve the 1-line instruction to set the local environment variables, which will be used for the following MCP server configuration
aws cloudformation describe-stacks \
--stack-name spark-troubleshooting-mcp-setup \
--region \
--query "Stacks[0].Outputs[?OutputKey=='ExportCommand'].OutputValue" \
--output text
```
Öffnen Sie die Registerkarte Ausgaben (oder rufen Sie sie mit dem obigen CLI-Befehl CloudFormation describe-stacks auf) und kopieren Sie die einzeilige Anweisung aus der CloudFormation Ausgabe, um Ihre Umgebungsvariablen festzulegen, und führen Sie sie dann in Ihrer lokalen Umgebung aus. Beispiel für eine einzeilige Anweisung:
```
export SMUS_MCP_REGION= && export IAM_ROLE=arn:aws:iam::111122223333:role/spark-troubleshooting-role-xxxxxx
```
Führen Sie dann den folgenden Befehl lokal aus, um das IAM-Profil und die MCP-Serverkonfiguration einzurichten:
```
# Step 1: Configure AWS CLI Profile
aws configure set profile.smus-mcp-profile.role_arn ${IAM_ROLE}
aws configure set profile.smus-mcp-profile.source_profile
aws configure set profile.smus-mcp-profile.region ${SMUS_MCP_REGION}
# Step 2: if you are using kiro CLI, use the following command to add the MCP configuration
# Add Spark Troubleshooting MCP Server
kiro-cli-chat mcp add \
--name "sagemaker-unified-studio-mcp-troubleshooting" \
--command "uvx" \
--args "[\"mcp-proxy-for-aws@latest\",\"https://sagemaker-unified-studio-mcp.${SMUS_MCP_REGION}.api.aws/spark-troubleshooting/mcp\", \"--service\", \"sagemaker-unified-studio-mcp\", \"--profile\", \"smus-mcp-profile\", \"--region\", \"${SMUS_MCP_REGION}\", \"--read-timeout\", \"180\"]" \
--timeout 180000 \
--scope global
# Add Spark Code Recommendation MCP Server
kiro-cli-chat mcp add \
--name "sagemaker-unified-studio-mcp-code-rec" \
--command "uvx" \
--args "[\"mcp-proxy-for-aws@latest\",\"https://sagemaker-unified-studio-mcp.${SMUS_MCP_REGION}.api.aws/spark-code-recommendation/mcp\", \"--service\", \"sagemaker-unified-studio-mcp\", \"--profile\", \"smus-mcp-profile\", \"--region\", \"${SMUS_MCP_REGION}\", \"--read-timeout\", \"180\"]" \
--timeout 180000 \
--scope global
```
Dies sollte aktualisiert `~/.kiro/settings/mcp.json` werden und die MCP-Serverkonfiguration wie folgt enthalten.
```
{
"mcpServers": {
"sagemaker-unified-studio-mcp-troubleshooting": {
"type": "stdio",
"command": "uvx",
"args": [
"mcp-proxy-for-aws@latest",
"https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-troubleshooting/mcp",
"--service",
"sagemaker-unified-studio-mcp",
"--profile",
"smus-mcp-profile",
"--region",
"us-east-1",
"--read-timeout",
"180"
],
"timeout": 180000,
"disabled": false
},
"sagemaker-unified-studio-mcp-code-rec": {
"type": "stdio",
"command": "uvx",
"args": [
"mcp-proxy-for-aws@latest",
"https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-code-recommendation/mcp",
"--service",
"sagemaker-unified-studio-mcp",
"--profile",
"smus-mcp-profile",
"--region",
"us-east-1",
"--read-timeout",
"180"
],
"timeout": 180000,
"disabled": false
}
}
}
```
Anleitungen [Unterstützte Schnittstellen](spark-troubleshooting-using-troubleshooting-agent.md#supported-interfaces) zur Konfiguration verschiedener MCP-Clients wie Kiro, Cline und finden Sie unter. GitHub CoPilot
# Den Troubleshooting Agent verwenden
## Unterstützte Bereitstellungsmodi
Der Apache Spark Troubleshooting Agent für Amazon EMR unterstützt umfassende Analysefunktionen für ausgefallene Spark-Workloads, einschließlich automatisierter Fehlerdiagnose, Identifizierung von Leistungsengpässen, Codeempfehlungen und umsetzbaren Vorschlägen für eine verbesserte Anwendungsleistung für den folgenden Spark-Bereitstellungsmodus:
+ EMR in EC2
+ EMR Serverlos
+ AWS Glue
Weitere Informationen [Funktionen und Fähigkeiten](spark-troubleshooting-features.md) zu den Funktionen, Kapazitäten und Einschränkungen finden Sie unter.
## Unterstützte Schnittstellen
### Fehlerbehebung bei Zellen in SageMaker Amazon-Notebooks
Eine Demonstration der Erfahrungen mit der Fehlerbehebung mit Amazon SageMaker Notebooks. Bei jedem Ausfall einer Notebook-Zelle können Sie den Amazon SageMaker Notebook-Agenten bitten, den Fehler beim Anfordern der Analyse zu beheben, gefolgt von einer möglichen Codekorrektur, falls der Fehler auf Code zurückzuführen ist, indem Sie auf die `Fix with AI` Schaltfläche klicken.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/btW8hwio0tE)
### Fehlerbehebung bei Glue- und EMR Spark-Anwendungen mit Kiro CLI
Starten Sie Kiro CLI oder Ihren AI Assistant und überprüfen Sie die geladenen Tools für den Fehlerbehebungsprozess.
```
...
sagemaker-unified-studio-mcp-code-rec (MCP)
- spark_code_recommendation not trusted
sagemaker-unified-studio-mcp-troubleshooting (MCP)
- analyze_spark_workload not trusted
...
```
Jetzt sind Sie bereit, den Spark-Troubleshooting-Agent-Workflow zu starten.
Eine Demonstration der Erfahrungen mit der Fehlerbehebung mit Kiro CLI. Sie können den Fehlerbehebungsprozess einfach mit der folgenden Aufforderung starten:
```
Analyze my Glue job. The job name is "xxx" and the job run id is "xxx"
```
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/YLwV_EenJXY)
### Integration mit anderen MCP-Clients
Die unter beschriebene Konfiguration [Einrichtung für den Troubleshooting Agent](spark-troubleshooting-agent-setup.md) kann auch in anderen MCP-Clients und IDEs zur Verbindung mit dem Managed MCP-Server verwendet werden:
+ **Integration mit Cline** — Um den MCP-Server mit Cline zu verwenden, ändern Sie die obige Konfiguration `cline_mcp_settings.json` und fügen Sie sie hinzu. Weitere Informationen zur [Verwaltung der MCP-Konfiguration finden Sie in der Dokumentation von Cline](https://docs.cline.bot/mcp/configuring-mcp-servers).
+ **Integration mit Claude Code** Um den MCP-Server mit Claude Code zu verwenden, ändern Sie die Konfigurationsdatei so, dass sie die MCP-Konfiguration enthält. Der Dateipfad variiert je nach Betriebssystem. Eine detaillierte Einrichtung finden Sie unter [ https://code.claude.com/docs/en/mcp](https://code.claude.com/docs/en/mcp).
+ **Integration mit GitHub Copilot — Um** den MCP-Server mit GitHub Copilot zu verwenden, folgen Sie den Anweisungen unter [ https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend—](https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend-copilot-chat-with-mcp), um die entsprechende Konfigurationsdatei copilot-chat-with-mcp zu ändern, und folgen Sie den Anweisungen für jede IDE, um das Setup zu aktivieren.
# Funktionen und Fähigkeiten
## Unterstützte Plattformen
+ **Sprachen**: Python- und Scala Spark-Anwendungen
+ **Zielplattformen**: Amazon EMR, EMR Serverless und Glue AWS
## So funktioniert’s
Wenn Ihre Spark-Anwendung ausfällt, können Sie den Troubleshooting-Agenten verwenden, um automatisch zu untersuchen, was schief gelaufen ist. Er analysiert Ihre Spark-Ereignisprotokolle, Fehlermeldungen und die Ressourcennutzung, um das genaue Problem zu lokalisieren — unabhängig davon, ob es sich um einen Spark-Executor handelt, dem der Speicher ausgeht, ein Konfigurationsfehler oder ein Code-Bug.
Wenn Sie eine Aufforderung in natürlicher Sprache bitten, Ihren Spark-Workload zu analysieren, stellt der Agent eine Verbindung zu den Ressourcen Ihrer Plattform her und extrahiert Funktionen (dazu gehören Spark-Ereignisprotokolle, Abfragepläne, Executor-Zeitpläne, Log-Traces, Konfigurationen und Metriken):
+ Auf EMR-EC2: Es stellt eine Verbindung zur [EMR Persistent](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html) UI für den Cluster her
+ Auf Glue: Es erstellt den Kontext aus der [Spark-Benutzeroberfläche](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html) von Glue Studio für den Job
+ [Auf EMR-Serverless: Es stellt für den Job eine Verbindung zum EMR-Serverless Spark History Server her](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_GetDashboardForJobRun.html)
+ Der Agent analysiert auch Ihre Error-Stack-Traces und Konfigurationsdetails, um Ihnen umsetzbare Erkenntnisse zu geben.
Bei ausgefallenen Workloads erhalten Sie eine klare Erklärung der Ursache und konkrete Schritte zur Behebung des Problems. Wenn der Agent ein Problem im Zusammenhang mit dem Code erkennt, gibt er automatisch Codeempfehlungen, die Ihnen genau zeigen, was Sie an Ihrem Code ändern müssen. Sie können auch jederzeit direkt Vorschläge auf Codeebene anfordern, ohne dass eine vollständige Analyse erforderlich ist.
## Verfügbare Regionen
Der Spark Troubleshooting Agent ist in den folgenden Regionen verfügbar:
+ **Asien-Pazifik**: Tokio (ap-northeast-1), Seoul (ap-northeast-2), Singapur (ap-southeast-1), Sydney (ap-southeast-2) und Mumbai (ap-south-1)
+ **Nordamerika**: Kanada (ca-central-1)
+ **Europa**: Stockholm (eu-north-1), Irland (eu-west-1), London (eu-west-2), Paris (eu-west-3) und Frankfurt (eu-central-1)
+ **Südamerika**: São Paulo (sa-east-1)
+ **Vereinigte Staaten**: Nord-Virginia (us-east-1), Ohio (us-east-2) und Oregon (US-West-2)
## Umfang der Spark-Fehlerbehebung und Benutzeranforderungen
+ **Status der unterstützten Spark-Workloads**: Die Tools unterstützen nur Antworten auf fehlgeschlagene Spark-Workloads.
+ **Persistent EMR UI:** Bei der Analyse von Amazon EMR-EC2-Workloads versucht das Analysetool, eine Verbindung zur EMR Persistent UI herzustellen, um wichtige Spark-Informationen abzurufen. Überlegungen zur persistenten Benutzeroberfläche von EMR sind [hier dokumentiert.](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html#app-history-spark-UI-limitations)
+ **Glue Studio Spark-Benutzeroberfläche**: Bei der Analyse von AWS Glue-Workloads versucht das Analysetool, wichtige Spark-Informationen abzurufen, indem es die Spark-Ereignisprotokolle des Benutzers aus Amazon S3 analysiert. Die maximal zulässige Größe des Spark-Ereignisprotokolls ist [hier](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html) dokumentiert: 512 MB und 2 GB für fortlaufende Logs.
+ **Codeempfehlungen: Wird** nur für Amazon EMR-EC2- und AWS Glue-Workloads für Workloads unterstützt PySpark
+ **Regionale Ressourcen:** Der Spark Troubleshooting Agent ist regional und verwendet die zugrunde liegenden EMR-Ressourcen in dieser Region für den Fehlerbehebungsprozess. Die regionsübergreifende Fehlerbehebung wird nicht unterstützt.
# Problembehandlung und Fragen und Antworten
## Fehlerbehebung
Die Fehlermeldung vom Spark Troubleshooting Agent ist für verschiedene MCP-Clients auf unterschiedliche Weise verfügbar. Auf dieser Seite finden Sie einige allgemeine Anleitungen für häufig auftretende Probleme, die bei der Verwendung des Apache Spark-Fehlerbehebungsagenten für Amazon EMR auftreten können.
Topics
+ [Fehler: Der MCP-Server konnte nicht geladen werden](#mcp-server-failed-to-load)
+ [Beobachtung: Langsames Laden des Tools](#slow-tool-loading)
+ [Fehler: Der Aufruf des Tools ist mit einem Drosselungsfehler fehlgeschlagen](#throttling-error)
+ [Fehler: Das Tool reagiert mit einem Benutzerfehler](#user-error)
+ [Fehler: Das Tool reagiert mit einem internen Fehler](#internal-error)
### Fehler: Der MCP-Server konnte nicht geladen werden
+ Stellen Sie sicher, dass Ihre MCP-Konfigurationen richtig konfiguriert sind.
+ **Überprüfen Sie die JSON-Syntax**:
+ Stellen Sie sicher, dass Ihr JSON gültig ist und keine Syntaxfehler enthält
+ Suchen Sie nach fehlenden Kommas, Anführungszeichen oder Klammern
+ Überprüfen Sie Ihre lokalen AWS Anmeldeinformationen und stellen Sie sicher, dass die Richtlinie für die MCP-IAM-Rolle ordnungsgemäß konfiguriert ist.
+ Führen Sie /mcp aus, um die Verfügbarkeit des MCP-Servers für den Fall zu überprüfen `Kiro-CLI`
### Beobachtung: Langsames Laden des Tools
+ Beim ersten Versuch, den Server zu starten, kann es einige Sekunden dauern, bis die Tools geladen sind.
+ Wenn die Tools nicht angezeigt werden, versuchen Sie, den Chat neu zu starten.
+ Führen Sie `/tools` den Befehl aus, um die Verfügbarkeit des Tools zu überprüfen.
+ Wird ausgeführt`/mcp`, wenn der Server ohne Fehler gestartet wird.
### Fehler: Der Aufruf des Tools ist mit einem Drosselungsfehler fehlgeschlagen
+ Wenn Sie Ihr Servicelimit erreicht haben, warten Sie bitte einige Sekunden, bis Sie einen Toolaufruf veranlassen, falls Sie die Drosselungsausnahme sehen.
### Fehler: Das Tool reagiert mit einem Benutzerfehler
+ AccessDeniedException - Überprüfen Sie die Fehlermeldung und beheben Sie das Berechtigungsproblem.
+ InvalidInputException - Überprüfen Sie die Fehlermeldung und korrigieren Sie die Eingabeparameter des Werkzeugs.
+ ResourceNotFoundException - Überprüfen Sie die Fehlermeldung und korrigieren Sie den Eingabeparameter als Ressourcenreferenz.
### Fehler: Das Tool reagiert mit einem internen Fehler
+ Wenn Sie das sehen, versuchen `The service is handling high-volume requests` Sie bitte in ein paar Sekunden erneut, das Tool aufzurufen.
+ Wenn Sie Folgendes sehen, dokumentieren `INTERNAL SERVICE EXCEPTION` Sie bitte die Analyse-ID, den Namen des Tools, alle im MCP-Protokoll oder der Tool-Antwort verfügbaren Fehlermeldungen und optional den bereinigten Konversationsverlauf und wenden Sie sich an den Support. AWS
## Fragen und Antworten
### 1. Sollte ich die Einstellung „Vertrauen“ für die Tools standardmäßig aktivieren?
Aktivieren Sie zunächst nicht die Einstellung „Vertrauen“ standardmäßig für alle Tool-Aufrufe und arbeiten Sie mit einer Build-Umgebung mit Git-Version, wenn Sie Codeempfehlungen akzeptieren. Überprüfen Sie jede Ausführung des Tools, um zu verstehen, welche Änderungen vorgenommen werden.
### 2. Was sind die häufigsten Beispielanweisungen zur Nutzung der Tools zur Fehlerbehebung?
Beispiele [Prompte Beispiele](spark-troubleshooting-agent-prompt-examples.md) für Eingabeaufforderungen zur Nutzung der Tools zur Fehlerbehebung finden Sie unter.
### 3. Welche Daten werden an das LLM übertragen und wie werden sie behandelt?
Kundendaten und Dateien verbleiben in der von Ihnen ausgewählten AWS Region und werden nicht regionsübergreifend übertragen. Wenn der Agent in einer Region tätig ist, die globale regionsübergreifende Inferenz von Amazon Bedrock verwendet, leitet der Service Anfragen je nach Bedarf an die nächstgelegene Region mit verfügbarer Kapazität weiter. In solchen Fällen werden nur extrahierte Metadaten aus Kundenprotokollen und verarbeitete Inferenzergebnisse übertragen, nicht die zugrunde liegenden Kundendaten oder Dateien. Alle Daten werden maskiert, bevor sie zur Verarbeitung an das LLM gesendet werden, unabhängig davon, ob die Inferenz in derselben Region stattfindet oder in eine andere Region weitergeleitet wird. Weitere Informationen darüber, wie regionsübergreifende Inferenzen funktionieren und welche Regionen davon betroffen sind, finden Sie unter. [Regionsübergreifende Verarbeitung für den Apache Spark Troubleshooting Agent](spark-troubleshooting-cross-region-processing.md)
# Der Arbeitsablauf für Spark-Agenten zur Fehlerbehebung im Detail
Um den Fehlerbehebungsprozess einzuleiten, benötigen Sie Zugriff auf Ihre ausgefallenen Spark-Anwendungskennungen, die auf unterstützten Plattformen (EMR-EC2, EMR Serverless, AWS Glue oder Amazon Data Notebooks) ausgeführt werden. SageMaker Die Anwendung sollte über zugängliche Protokolle, Spark History Server und Konfigurationsdetails verfügen. Stellen Sie sicher, dass Sie über die erforderlichen Berechtigungen für den Zugriff auf die Plattformressourcen und Anwendungsmetadaten verfügen. Sobald diese Anforderungen festgelegt sind, können Sie eine Aufforderung wie die folgende einreichen, um den Workflow zur Fehlerbehebung einzuleiten:
```
Analyze my EMR step execution failure, EMR id with cluster id
```
Zu diesem Zeitpunkt orchestriert der Agent die Fehlerbehebung mithilfe spezieller Tools. Der Workflow folgt diesen Schritten:
1. **Funktionsextraktion und Kontexterstellung**: Der Agent sammelt und analysiert automatisch Telemetriedaten aus Ihrer Spark-Anwendung, einschließlich History Server-Protokollen, Konfigurationseinstellungen und Fehlerablaufzeichnungen. Sie werden sehen, wie das Tool Informationen über Leistungskennzahlen, Ressourcennutzungsmuster und Fehlersignaturen sammelt.
1. **Analyse und Ursachenidentifikation**: Der Agent nutzt KI-Modelle und die Spark-Wissensdatenbank, um extrahierte Funktionen zu korrelieren und die Hauptursachen von Leistungsproblemen oder Ausfällen zu identifizieren. Sie erhalten:
+ **Einblicke in die Analyse**: Technische Details darüber, was der Agent entdeckt und analysiert hat.
+ **Ursache**: Klare Erklärung, was schief gelaufen ist und warum.
+ **Erste Bewertung**: Unabhängig davon, ob das Problem code-, konfigurations- oder ressourcenbezogen ist, werden einige allgemeine Hinweise und Analysen zur Abhilfemaßnahme bereitgestellt.
1. **Codeempfehlungen** (falls zutreffend): Wenn bei der Analyse anhand der Fehlerklassifizierung Probleme im Zusammenhang mit dem Code identifiziert werden, kann der Kundendienstmitarbeiter vorschlagen, das Codeempfehlungstool zu nutzen, um spezifische Empfehlungen zur Implementierung der empfohlenen Codekorrektur mit exaktem Code und Ersatzvorschlägen abzugeben. before/after
Der Fehlerbehebungsprozess ist iterativ — Sie können das Gespräch fortsetzen, um sich eingehender mit bestimmten Problemen zu befassen. Sie können die Tools auch interaktiv in unserer lokalen Spark-Codeentwicklung verwenden, um Codefehler zu beheben oder Ihren Code kontinuierlich zu verbessern.
# Prompte Beispiele
Im Folgenden finden Sie eine Liste von Beispielen für Eingabeaufforderungen, die bei der Problembehandlung verwendet werden können.
## 1. Beheben Sie den Fehler bei der Ausführung des Spark-Jobs
EMR auf EC2 Fehlerbehebung:
```
Troubleshoot my EMR-EC2 step with id s-xxxxxxxxxxxx on cluster j-xxxxxxxxxxxxx
```
Fehlerbehebung bei Klebejobs:
```
Troubleshoot my Glue job with job run id jr_xxxxxxxxxxxxxxxxxxxxxxxxxxxx and job name test_job
```
Serverlose EMR-Fehlerbehebung:
```
Troubleshoot my EMR-Serverless job run with application id 00xxxxxxxx and job run id 00xxxxxxxx
```
## 2. Bitte um Empfehlung zur Korrektur des Codes
Fordern Sie eine Codefix-Empfehlung für EMR im EC2-Job an:
```
Recommend code fix for my EMR-EC2 step with id s-STEP_ID on cluster j-CLUSTER_ID
```
Empfehlung zur Codekorrektur für den Glue-Job anfordern:
```
Recommend code fix for my Glue job with job run id jr_JOB_RUN_ID and job name test_job
```
# Einrichtung der IAM-Rolle
Der CloudFormation Stack in den Setup-Anweisungen automatisiert die Einrichtung der IAM-Rolle für Sie. Wenn Sie ihn manuell ausführen möchten, folgen Sie bitte den folgenden Anweisungen:
## Einrichtung der IAM-Rolle für den MCP-Server
Für den Zugriff auf den SMUS-verwalteten MCP-Server ist eine IAM-Rolle mit der folgenden Inline-Richtlinie erforderlich:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowUseSagemakerUnifiedStudioMcpServer",
"Effect": "Allow",
"Action": [
"sagemaker-unified-studio-mcp:InvokeMcp",
"sagemaker-unified-studio-mcp:CallReadOnlyTool",
"sagemaker-unified-studio-mcp:CallPrivilegedTool"
],
"Resource": [
"*"
]
}
]
}
```
In den nächsten Schritten werden wir ein Profil für diese Rolle erstellen. Das Konto, das diese Rolle zum Abrufen der Anmeldeinformationen übernimmt, sollte der Richtlinie zur Übernahme der Rolle hinzugefügt werden.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowAccountToAssumeRole",
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam:::root" },
"Action": "sts:AssumeRole"
}
]
}
```
## Zusätzliche Berechtigungen nach Bereitstellungsmodus (EMR-EC2/EMR-S/Glue)
### EMR-EC2-Anwendungen
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "EMREC2ReadAccess",
"Effect": "Allow",
"Action": [
"elasticmapreduce:DescribeCluster",
"elasticmapreduce:DescribeStep",
"elasticmapreduce:ListSteps",
"elasticmapreduce:ListClusters",
"elasticmapreduce:DescribeJobFlows"
],
"Resource": [
"*"
]
},
{
"Sid": "EMRS3LogAccess",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": "*"
},
{
"Sid": "EMRPersistentApp",
"Effect": "Allow",
"Action": [
"elasticmapreduce:CreatePersistentAppUI",
"elasticmapreduce:DescribePersistentAppUI",
"elasticmapreduce:GetPersistentAppUIPresignedURL"
],
"Resource": [
"*"
]
}
]
}
```
### Kleberjobs
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "GlueReadAccess",
"Effect": "Allow",
"Action": [
"glue:GetJob",
"glue:GetJobRun",
"glue:GetJobRuns",
"glue:GetJobs",
"glue:BatchGetJobs"
],
"Resource": [
"arn:aws:glue:*::job/*"
]
},
{
"Sid": "GlueCloudWatchLogsAccess",
"Effect": "Allow",
"Action": [
"logs:GetLogEvents",
"logs:FilterLogEvents"
],
"Resource": [
"arn:aws:logs:*::log-group:/aws/glue/*"
]
},
{
"Sid": "GlueSparkWebUI",
"Effect": "Allow",
"Action": [
"glue:RequestLogParsing",
"glue:GetLogParsingStatus",
"glue:GetEnvironment",
"glue:GetStage",
"glue:GetStages",
"glue:GetStageFiles",
"glue:BatchGetStageFiles",
"glue:GetStageAttempt",
"glue:GetStageAttemptTaskList",
"glue:GetStageAttemptTaskSummary",
"glue:GetExecutors",
"glue:GetExecutorsThreads",
"glue:GetStorage",
"glue:GetStorageUnit",
"glue:GetQueries",
"glue:GetQuery",
"glue:GetDashboardUrl"
],
"Resource": [
"arn:aws:glue:*::job/*"
]
},
{
"Sid": "GluePassRoleAccess",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringLike": {
"iam:PassedToService": "glue.amazonaws.com"
}
}
}
]
}
```
### Serverlose EMR-Anwendungen
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "EMRServerlessReadAccess",
"Effect": "Allow",
"Action": [
"emr-serverless:GetJobRun",
"emr-serverless:GetApplication",
"emr-serverless:ListApplications",
"emr-serverless:ListJobRuns",
"emr-serverless:ListJobRunAttempts",
"emr-serverless:GetDashboardForJobRun",
"emr-serverless:ListTagsForResource"
],
"Resource": [
"*"
]
},
{
"Sid": "EMRServerlessCloudWatchLogsAccess",
"Effect": "Allow",
"Action": [
"logs:GetLogEvents",
"logs:FilterLogEvents"
],
"Resource": [
"arn:aws:logs:*::log-group:/aws/emr-serverless/*"
]
},
{
"Sid": "EMRServerlessS3LogsAccess",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": "*"
}
]
}
```
### KMS-Berechtigungen — Protokolle CloudWatch
Wenn die CloudWatch Protokolle mit einem CMK verschlüsselt sind, fügen Sie die folgende Richtlinie hinzu, damit der Service die EMR-Serverless-Anwendungsprotokolle lesen kann.
```
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:::key/"
}
```
# Verwenden der Spark-Tools zur Fehlerbehebung
## Verfügbare Tools zur Fehlerbehebung
Der MCP-Service bietet verschiedene Tools für den Spark Troubleshooting Agent. Die wichtigsten Tools sind die folgenden:
| Name des Tools | Kategorie des Werkzeugs | Description |
| --- | --- | --- |
| analyze\$1spark\$1workload | Ursachenanalyse | Bietet eine detaillierte Problembehebung für fehlgeschlagene Apache Spark-Workloads |
| spark\$1code\$1recommendation | Empfehlung zur Codekorrektur | Bietet Apache Spark-Codeempfehlungen für fehlgeschlagene Jobs |
# Konfiguration von Schnittstellen-VPC-Endpunkten für Amazon SageMaker Unified Studio MCP
Sie können eine private Verbindung zwischen Ihrer VPC und dem Amazon SageMaker Unified Studio MCP-Service herstellen, indem Sie einen *VPC-Schnittstellen-Endpunkt* erstellen. Schnittstellenendpunkte werden von [Amazon VPC](https://aws.amazon.com/vpc/) betrieben, sodass Sie ohne Internet-Gateway, NAT-Gerät, VPN-Verbindung oder Verbindung privat auf den MCP-Server in Ihrer VPC zugreifen können. Instances in Ihrer VPC benötigen keine öffentlichen IP-Adressen, um mit dem MCP-Service zu kommunizieren, und der Datenverkehr zwischen Ihrer VPC und dem MCP-Service verlässt das Amazon-Netzwerk nicht.
Jeder Schnittstellenendpunkt wird durch eine oder mehrere [Elastic Network Interfaces](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) in Ihren VPC-Subnetzen repräsentiert. Weitere Informationen finden Sie unter [Interface VPC Endpoints](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) im *Amazon VPC-Benutzerhandbuch*.
## Schritt 1: Erstellen eines VPC-Schnittstellen-Endpunkts für Amazon SageMaker Unified Studio MCP
Sie können einen VPC-Endpunkt für den Amazon SageMaker Unified Studio MCP Service entweder mit der Amazon VPC-Konsole oder dem erstellen. AWS CLI Weitere Informationen finden Sie unter [Erstellung eines Schnittstellenendpunkts](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) im *Benutzerhandbuch für Amazon VPC*.
Erstellen Sie einen VPC-Endpunkt für Amazon SageMaker Unified Studio MCP mit dem folgenden Servicenamen:
+ com.amazonaws. **. sagemaker-unified-studio-mcp
Wenn Sie privates DNS für den Endpunkt aktivieren, können Sie API-Anfragen an Amazon SageMaker Unified Studio MCP stellen, indem Sie dessen Standard-DNS-Namen für die Region verwenden, zum Beispiel `sagemaker-unified-studio-mcp.us-east-1.api.aws`
Weitere Informationen finden Sie unter [Zugriff auf einen Service über einen Schnittstellenendpunkt](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#access-service-though-endpoint) im *Benutzerhandbuch für Amazon VPC*.
## Schritt 2: Erstellen einer VPC-Endpunktrichtlinie für Amazon SageMaker Unified Studio MCP
Sie können Ihrem VPC-Endpunkt eine Endpunktrichtlinie hinzufügen, die den Zugriff auf Amazon SageMaker Unified Studio MCP steuert. Die Richtlinie gibt die folgenden Informationen an:
+ Prinzipal, der die Aktionen ausführen kann.
+ Aktionen, die ausgeführt werden können
+ Die Ressourcen, für die Aktionen ausgeführt werden können.
Weitere Informationen finden Sie unter [Steuerung des Zugriffs auf Services mit VPC-Endpunkten](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) im *Amazon-VPC-Benutzerhandbuch*.
### Beispiel: VPC-Endpunktrichtlinie, um MCP-Zugriff auf eine bestimmte IAM-Rolle zu ermöglichen
Im Folgenden finden Sie ein Beispiel für eine Endpunktrichtlinie für den MCP-Zugriff auf Amazon SageMaker Unified Studio. Wenn diese Richtlinie an einen Endpunkt angehängt ist, gewährt sie Zugriff auf die aufgelisteten Amazon SageMaker Unified Studio MCP-Aktionen für einen bestimmten IAM-Rollenprinzipal auf allen Ressourcen.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::ACCOUNT-ID:role/YourRoleName"
},
"Action": [
"sagemaker-unified-studio-mcp:InvokeMcp",
"sagemaker-unified-studio-mcp:CallReadOnlyTool",
"sagemaker-unified-studio-mcp:CallPrivilegedTool"
],
"Resource": "*"
}
]
}
```
## Schritt 3: Testen Sie Ihre VPC
Der `curl` Befehl validiert die end-to-end Netzwerkkonnektivität von Ihrem VPC-Netzwerk (EC2) zum VPC-Endpunkt, indem er eine Anfrage stellt. HTTP/HTTPS Eine Curl-Antwort, bei der eine Nachricht vom MCP-Server empfangen wird, bestätigt, dass der gesamte Netzwerkpfad funktionsfähig ist.
### Methode 1: Mit aktiviertem privaten DNS (empfohlen)
```
curl https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-troubleshooting/mcp
```
### Methode 2: Ohne aktiviertes privates DNS
```
curl -k https://vpce-0069xxxx-ejwhxxx.sagemaker-unified-studio-mcp.us-east-1.vpce.amazonaws.com/spark-troubleshooting/mcp
```
**Anmerkung**
Das `-k` Flag umgeht die SSL-Zertifikatsverifizierung, da der Hostname zwischen dem DNS-Namen des VPC-Endpunkts und dem Common Name (CN) des Zertifikats nicht übereinstimmt.
In beiden Fällen gibt der Befehl curl eine Antwort zurück:. `{"Message":"...."}` Bei der Rückgabe mit einer Nachricht wird die erfolgreiche Netzwerkpfadkonnektivität zum VPC-Endpunkt des MCP-Dienstes überprüft.
## Schritt 4: Beginnen Sie mit der Verwendung des MCP-VPC-Endpunkts
Nachdem Sie die Verbindung überprüft haben, können Sie den Schritten zur Konfiguration des MCP in folgen. [Einrichtung für den Troubleshooting Agent](spark-troubleshooting-agent-setup.md) Verwenden Sie einfach den privaten VPC-Endpunkt in Ihrer MCP-Konfiguration.
# Regionsübergreifende Verarbeitung für den Apache Spark Troubleshooting Agent
Der Apache Spark Troubleshooting Agent verwendet regionsübergreifende Inferenz, um Anfragen in natürlicher Sprache zu verarbeiten und Antworten zu generieren. Bei regionsübergreifender Inferenz leitet der Agent Ihre Inferenzanfrage automatisch weiter, um die Leistung zu optimieren, die verfügbaren Rechenressourcen und die Modellverfügbarkeit zu maximieren und das beste Kundenerlebnis zu bieten. Die Art der verwendeten regionsübergreifenden Inferenz hängt von der Region ab, in der Sie den Apache Spark Troubleshooting Agent ausführen. In den meisten Regionen wählt der Agent die optimale Region innerhalb Ihrer Region für die Bearbeitung Ihrer Inferenzanfragen aus. In einigen Regionen wird eine vom Agenten gestellte Inferenzanfrage jedoch sicher an alle verfügbaren Rechenressourcen in allen globalen Handelsregionen weitergeleitet. AWS
## Regionsübergreifende Inferenz
Der Apache Spark Troubleshooting-Agent wird von Amazon Bedrock unterstützt und verwendet regionsübergreifende Inferenz, um den Datenverkehr auf verschiedene AWS Regionen zu verteilen, um die Leistung und Zuverlässigkeit von Large Language Model (LLM) -Inferenzen zu verbessern.
Die regionsübergreifende Inferenz ändert zwar nichts daran, wo Ihre Spark-Anwendung oder Ihre Problembehebung gehostet oder Ihre Daten gespeichert werden, aber Ihre Eingabeaufforderungen und Ausgabeergebnisse können zur Inferenzverarbeitung in verschiedene Regionen übertragen werden. Alle Daten werden verschlüsselt über das sichere Netzwerk von Amazon übertragen.
Für die Verwendung regionsübergreifender Inferenz fallen keine zusätzlichen Kosten an.
## Unterstützte Regionen für regionsübergreifende Inferenz
**Regionen, die geografische regionsübergreifende Inferenz verwenden**
In den meisten Regionen werden regionsübergreifende Inferenzanfragen innerhalb von AWS Regionen gespeichert, die Teil derselben Region sind, in der Sie den Apache Spark Troubleshooting Agent ausführen. Beispielsweise wird eine Anfrage des Agenten in der Region USA Ost (Nord-Virginia) nur an AWS Regionen innerhalb der Geografie der Vereinigte Staaten weitergeleitet. In der folgenden Tabelle wird beschrieben, in welche Regionen Ihre Anfragen je nach Region weitergeleitet werden können, aus der die Anfrage stammt:
| Unterstützte Geografie | Inferenzregionen |
| --- | --- |
| Vereinigte Staaten | USA Ost (Nord-Virginia) (us-east-1), USA West (Oregon) (US-West-2), USA Ost (Ohio) (us-east-2), USA West (Nordkalifornien) (US-West-1) |
| Europa | Europa (Frankfurt) (eu-central-1), Europa (Irland) (eu-west-1), Europa (Paris) (eu-west-3), Europa (Stockholm) (eu-north-1), Europa (London) (eu-west-2) |
| Asien-Pazifik | Asien-Pazifik (Tokio) (ap-northeast-1), Asien-Pazifik (Seoul) (ap-northeast-2), Asien-Pazifik (Mumbai) (ap-south-1) |
### Regionen, die globale regionsübergreifende Inferenz verwenden
**Wichtig**
Die folgenden AWS Regionen verwenden globale regionsübergreifende Inferenz. Wenn Sie den Apache Spark Troubleshooting Agent in diesen Regionen verwenden, können Ihre Anfragen zur Inferenzverarbeitung global in andere AWS Regionen übertragen werden, um Leistung und Verfügbarkeit zu optimieren:
Südamerika (São Paulo) (sa-east-1)
Asien-Pazifik (Singapur): (ap-southeast-1)
Asien-Pazifik (Sydney): (ap-southeast-2)
Kanada (Zentral): (ca-central-1)
# Protokollieren von Amazon SageMaker Unified Studio MCP-Aufrufen mit AWS CloudTrail
Amazon SageMaker Unified Studio MCP Server ist in einen Service integriert AWS CloudTrail, der eine Aufzeichnung der Aktionen bereitstellt, die von einem Benutzer, einer Rolle oder einem AWS Service in Amazon SageMaker Unified Studio MCP Server ausgeführt wurden. CloudTrail erfasst alle API-Aufrufe für Amazon SageMaker Unified Studio MCP Server als Ereignisse. Zu den erfassten Aufrufen gehören Aufrufe an Amazon SageMaker Unified Studio MCP Server und Codeaufrufen für andere AWS Operationen während der Toolausführungen vom SageMaker Unified Studio MCP Server aus. Wenn Sie einen Trail erstellen, können Sie die kontinuierliche Bereitstellung von CloudTrail Ereignissen an einen Amazon S3 S3-Bucket aktivieren, einschließlich Ereignissen für Amazon SageMaker Unified Studio MCP Server. Wenn Sie keinen Trail konfigurieren, können Sie die neuesten Ereignisse trotzdem in der CloudTrail Konsole im **Ereignisverlauf** anzeigen. Anhand der von gesammelten Informationen können Sie die Anfrage CloudTrail, die an den Amazon SageMaker Unified Studio MCP Server gestellt wurde, die IP-Adresse, von der aus die Anfrage gestellt wurde, wer die Anfrage gestellt hat, wann sie gestellt wurde, und weitere Details ermitteln.
Weitere Informationen CloudTrail dazu finden Sie im [AWS CloudTrail Benutzerhandbuch](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## Informationen zum Amazon SageMaker Unified Studio MCP Server in CloudTrail
CloudTrail ist für Ihr AWS Konto aktiviert, wenn Sie das Konto erstellen. Wenn eine Aktivität auf dem Amazon SageMaker Unified Studio MCP Server auftritt, wird diese Aktivität zusammen mit anderen AWS Serviceereignissen in der CloudTrail **Ereignishistorie in einem Ereignis** aufgezeichnet. Sie können aktuelle Ereignisse in Ihrem AWS Konto anzeigen, suchen und herunterladen. Weitere Informationen finden Sie unter [Ereignisse mit dem CloudTrail Ereignisverlauf anzeigen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Für eine fortlaufende Aufzeichnung der Ereignisse in Ihrem AWS Konto, einschließlich Ereignissen für SageMaker Unified Studio MCP Server, erstellen Sie einen Trail. Ein Trail ermöglicht CloudTrail die Übermittlung von Protokolldateien an einen Amazon S3 S3-Bucket. Wenn Sie einen Trail in der Konsole erstellen, gilt der Trail standardmäßig für alle AWS Regionen. Der Trail protokolliert Ereignisse aus allen Regionen der AWS Partition und übermittelt die Protokolldateien an den von Ihnen angegebenen Amazon S3 S3-Bucket. Darüber hinaus können Sie andere AWS Dienste konfigurieren, um die in den CloudTrail Protokollen gesammelten Ereignisdaten weiter zu analysieren und darauf zu reagieren. Weitere Informationen finden Sie hier:
+ [Übersicht zum Erstellen eines Trails](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail unterstützte Dienste und Integrationen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html)
+ [Konfiguration von Amazon SNS SNS-Benachrichtigungen für CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/configure-sns-notifications-for-cloudtrail.html)
+ [Empfangen von CloudTrail Protokolldateien aus mehreren Regionen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) und [Empfangen von CloudTrail Protokolldateien von mehreren Konten](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
Alle Aufrufe des SageMaker Unified Studio MCP Server-Tools und API-Aufrufe von AWS Diensten während der Ausführung des Tools werden von protokolliert. CloudTrail Beispielsweise generieren Aufrufe der verschiedenen Tools und AWS Serviceaufrufen, die von den Tools aus getätigt werden, Einträge in den Protokolldateien. CloudTrail
Jeder Ereignis- oder Protokolleintrag enthält Informationen zu dem Benutzer, der die Anforderung generiert hat. Die Identitätsinformationen unterstützen Sie bei der Ermittlung der folgenden Punkte:
+ Gibt an, ob die Anforderung mit Root- oder IAM-Benutzer-Anmeldeinformationen ausgeführt wurde.
+ Gibt an, ob die Anforderung mit temporären Sicherheitsanmeldeinformationen für eine Rolle oder einen Verbundbenutzer gesendet wurde.
+ Ob die Anfrage von einem anderen AWS Dienst gestellt wurde.
Weitere Informationen finden Sie unter [CloudTrail -Element userIdentity](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
## Grundlegendes zu Amazon SageMaker Unified Studio MCP Server-Protokolldateieinträgen
Ein Trail ist eine Konfiguration, die die Übertragung von Ereignissen als Protokolldateien an einen von Ihnen angegebenen Amazon S3 S3-Bucket ermöglicht. CloudTrail Protokolldateien enthalten einen oder mehrere Protokolleinträge. Ein Ereignis stellt eine einzelne Anforderung aus einer beliebigen Quelle dar und enthält Informationen über die angeforderte Aktion, Datum und Uhrzeit der Aktion, Anforderungsparameter usw. CloudTrail Protokolldateien sind kein geordneter Stack-Trace der öffentlichen API-Aufrufe, sodass sie nicht in einer bestimmten Reihenfolge angezeigt werden.
Das folgende Beispiel zeigt einen CloudTrail Protokolleintrag, der die `CallTool` Aktion demonstriert.
```
{
"eventVersion": "1.09",
"userIdentity": {
...
},
"eventTime": "...",
"eventSource": "sagemaker-unified-studio-mcp.amazonaws.com",
"eventName": "CallPrivilegedTool",
"awsRegion": "us-east-1",
"sourceIPAddress": "...",
"userAgent": "...",
"requestParameters": {
"id": 1,
"method": "tools/call",
"params": {
"name": "generate_spark_upgrade_plan",
"arguments": "***",
"_meta": {
"progressToken": 1
}
},
"jsonrpc": "2.0"
},
"responseElements": {
"result": {
"content": "***",
"structuredContent": "***",
"isError": false
},
"id": 1,
"jsonrpc": "2.0"
},
"requestID": "12345678-1234-1234-1234-123456789012",
"eventID": "87654321-4321-4321-4321-210987654321",
"readOnly": false,
"eventType": "AwsMcpEvent",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management"
}
```
Das folgende Beispiel zeigt einen CloudTrail Protokolleintrag, der die `AddJobFlowSteps` Aktion von Amazon SageMaker Unified Studio MCP während eines Aufrufs des Upgrade-Tools demonstriert.
```
{
"eventVersion": "1.11",
"userIdentity": {
"type": "AssumedRole",
"principalId": "...",
"arn": "...",
"accountId": "123456789012",
"accessKeyId": "...",
"sessionContext": {
...
},
"invokedBy": "sagemaker-unified-studio-mcp.amazonaws.com"
},
"eventTime": "...",
"eventSource": "elasticmapreduce.amazonaws.com",
"eventName": "AddJobFlowSteps",
"awsRegion": "us-east-1",
"sourceIPAddress": "sagemaker-unified-studio-mcp.amazonaws.com",
"userAgent": "sagemaker-unified-studio-mcp.amazonaws.com",
"requestParameters": {
"jobFlowId": "j-2PY4KXXXXXX63",
"steps": [
...
]
},
"responseElements": {
"stepIds": [
...
]
},
"requestID": "12345678-1234-1234-1234-123456789013",
"eventID": "87654321-4321-4321-4321-210987654322",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"sharedEventID": "12345678-1234-1234-1234-123456789012",
"vpcEndpointId": "sagemaker-unified-studio-mcp.amazonaws.com",
"vpcEndpointAccountId": "sagemaker-unified-studio-mcp.amazonaws.com",
"eventCategory": "Management"
}
```
# Serviceverbesserungen für Apache Spark-Agenten
Der Apache Spark-Agent für Amazon EMR kann Inhalte verwenden, um dem Agenten beispielsweise zu helfen, bessere Antworten auf häufig gestellte Fragen zu geben, Betriebsprobleme zu beheben oder um zu debuggen.
## Inhalte, die zur AWS Serviceverbesserung verwendet werden können
+ Ihre Eingabeaufforderungen und generierten Antworten in natürlicher Sprache von den Apache Spark-Agenten für Amazon EMR, AWS Glue und Amazon Notebooks SageMaker
## Inhalte, die AWS nicht zur Serviceverbesserung verwendet werden
+ Code, den Sie selbst für die Spark-Anwendungen schreiben
+ SageMaker Notizbuch-Kontext und Metadaten
+ Daten aus Ihrem AWS Glue-Datenkatalog oder anderen Datenquellen
Nur Amazon-Mitarbeiter haben Zugriff auf die Daten. Ihr Vertrauen, Ihre Privatsphäre und die Sicherheit Ihrer Kundeninhalte haben für uns höchste Priorität und wir stellen sicher, dass unsere Nutzung unseren Verpflichtungen Ihnen gegenüber entspricht. Weitere Informationen finden Sie in den Häufig gestellten Fragen zum Datenschutz.
## Wie kann ich mich abmelden
Um die Datenerfassung für die Apache Spark-Agenten zu deaktivieren, konfigurieren Sie in AWS Organizations for Amazon SageMaker Unified Studio MCP Service eine Opt-Out-Richtlinie für KI-Dienste. Weitere Informationen finden Sie in den [Opt-Out-Richtlinien für KI-Dienste](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) im *AWS Organizations User Guide*.
Wenn Sie eine Opt-Out-Richtlinie für KI-Dienste konfigurieren, hat dies folgende Auswirkungen:
+ AWS löscht die Daten, die es vor Ihrer Abmeldung gesammelt und gespeichert hat, um den Service zu verbessern (falls vorhanden).
+ Nach Ihrer Abmeldung AWS werden diese Daten nicht mehr gesammelt oder gespeichert.
+ AWS wird Ihre Inhalte nicht mehr zur Verbesserung des Dienstes verwenden.
# Die Leistung von Spark optimieren
Amazon EMR bietet mehrere Features für die Leistungsoptimierung von Spark. In diesem Thema werden die einzelnen Optimierungsfunktionen im Detail erläutert.
Weitere Informationen zum Festlegen der Spark-Konfiguration finden Sie unter [Konfigurieren von Spark](emr-spark-configure.md).
## Adaptive Abfrageausführung
Die adaptive Abfrageausführung ist ein Framework zur Neuoptimierung von Abfrageplänen auf der Grundlage von Laufzeitstatistiken. Ab Amazon EMR 5.30.0 sind die folgenden Optimierungen für die adaptive Abfrageausführung von Apache Spark 3 auf Apache-Amazon-EMR-Laufzeit für Spark 2 verfügbar.
+ Adaptive Join-Konvertierung
+ Adaptives Zusammenführen von Shuffle-Partitionen
**Adaptive Join-Konvertierung**
Die adaptive Join-Konvertierung verbessert die Abfrageleistung, indem sort-merge-join Operationen in Operationen umgewandelt werden, broadcast-hash-joins die auf der Laufzeitgröße der Abfragephasen basieren. Broadcast-hash-joinstendieren dazu, bessere Ergebnisse zu erzielen, wenn eine Seite des Joins klein genug ist, um seine Ausgabe effizient an alle Executoren zu verteilen. Dadurch entfällt die Notwendigkeit, den Austausch zu mischen und beide Seiten des Joins zu sortieren. Die adaptive Join-Konvertierung erweitert das Spektrum der Fälle, in denen Spark automatisch ausgeführt wird. broadcast-hash-joins
Dieses Feature ist standardmäßig aktiviert. Sie kann deaktiviert werden, indem `spark.sql.adaptive.enabled` auf `false` gesetzt wird, wodurch auch der adaptive Abfrageausführungsrahmen deaktiviert wird. Spark entscheidet, a in a sort-merge-join zu konvertieren, broadcast-hash-join wenn die Laufzeitgrößenstatistik einer der Join-Seiten den Standardwert von 10.485.760 Byte (10 MiB) nicht überschreitet`spark.sql.autoBroadcastJoinThreshold`.
**Adaptives Zusammenführen von Shuffle-Partitionen**
Das adaptive Zusammenführen von Shuffle-Partitionen verbessert die Abfrageleistung, indem kleine zusammenhängende Shuffle-Partitionen zusammengeführt werden, um den Mehraufwand zu vermeiden, der durch zu viele kleine Aufgaben entsteht. Auf diese Weise können Sie eine höhere Anzahl von anfänglichen Shuffle-Partitionen konfigurieren, die dann zur Laufzeit auf eine bestimmte Größe reduziert werden, wodurch sich die Wahrscheinlichkeit erhöht, dass Shuffle-Partitionen gleichmäßiger verteilt werden.
Dieses Feature ist standardmäßig aktiviert, sofern nicht ausdrücklich `spark.sql.shuffle.partitions` festgelegt ist. Sie kann aktiviert werden, indem Sie `spark.sql.adaptive.coalescePartitions.enabled` auf `true` einstellen. Sowohl die anfängliche Anzahl der Shuffle-Partitionen als auch die Größe der Zielpartition können mit den Eigenschaften `spark.sql.adaptive.coalescePartitions.minPartitionNum` und `spark.sql.adaptive.advisoryPartitionSizeInBytes` eingestellt werden. In der folgenden Tabelle finden Sie weitere Informationen zu den zugehörigen Spark-Eigenschaften für dieses Feature.
**Adaptive Koaleszenzpartitionseigenschaften von Spark**
| Eigenschaft | Standardwert | Description |
| --- | --- | --- |
| `spark.sql.adaptive.coalescePartitions.enabled` | „Wahr“, sofern `spark.sql.shuffle.partitions` nicht explizit festgelegt ist | Wenn „Wahr“ und spark.sql.adaptive.enabled den Wert „Wahr“ hat, fügt Spark zusammenhängende Shuffle-Partitionen entsprechend der Zielgröße (angegeben durch `spark.sql.adaptive.advisoryPartitionSizeInBytes`) zusammen, um zu viele kleine Aufgaben zu vermeiden. |
| `spark.sql.adaptive.advisoryPartitionSizeInBytes` | 64 MB | Die empfohlene Größe der Shuffle-Partition beim Zusammenführen. Diese Konfiguration wirkt sich nur aus, wenn `spark.sql.adaptive.enabled` und `spark.sql.adaptive.coalescePartitions.enabled` beide gleichzeitig `true` sind. |
| `spark.sql.adaptive.coalescePartitions.minPartitionNum` | 25 | Die Mindestanzahl der Shuffle-Partitionen nach dem Zusammenführen. Diese Konfiguration wirkt sich nur aus, wenn `spark.sql.adaptive.enabled` und `spark.sql.adaptive.coalescePartitions.enabled` beide gleichzeitig `true` sind. |
| `spark.sql.adaptive.coalescePartitions.initialPartitionNum` | 1000 | Die anfängliche Anzahl von Shuffle-Partitionen vor dem Zusammenführen. Diese Konfiguration wirkt sich nur aus, wenn `spark.sql.adaptive.enabled` und `spark.sql.adaptive.coalescePartitions.enabled` beide gleichzeitig `true` sind. |
## Dynamische Partitionsbereinigung
Die dynamische Partitionsbereinigung verbessert die Auftragsleistung durch eine sorgfältigere Auswahl der spezifischen Partitionen in einer Tabelle, die für eine bestimmte Abfrage gelesen und verarbeitet werden müssen. Indem Sie die Datenmenge reduzieren, die für die Ausführung eines Auftrags gelesen und verarbeitet werden muss, können Sie viel Zeit sparen. In Amazon EMR 5.26.0 ist dieses Feature standardmäßig aktiviert. In Amazon EMR 5.24.0 und 5.25.0 können Sie dieses Feature aktivieren, indem Sie die Spark-Eigenschaft `spark.sql.dynamicPartitionPruning.enabled` innerhalb von Spark oder beim Erstellen von Clustern festlegen.
**Dynamisches Löschen von Partitionen in Spark, Partitionseigenschaften**
| Eigenschaft | Standardwert | Description |
| --- | --- | --- |
| `spark.sql.dynamicPartitionPruning.enabled` | `true` | Wenn der Wert wahr ist, aktivieren Sie das dynamische Bereinigen von Partitionen. |
| `spark.sql.optimizer.dynamicPartitionPruning.enforceBroadcastReuse` | `true` | Wenn `true`, führt Spark vor der Ausführung der Abfrage eine Defensivprüfung durch, um sicherzustellen, dass die Wiederverwendung von Broadcast-Austauschen in dynamischen Bereinigungsfiltern nicht durch spätere Vorbereitungsregeln, wie z. B. benutzerdefinierte Spaltenregeln, beeinträchtigt wird. Wenn die Wiederverwendung nicht funktioniert und diese Konfiguration `true` ist, entfernt Spark die betroffenen dynamischen Bereinigungsfilter, um Leistungs- und Korrektheitsprobleme zu vermeiden. Korrektheitsprobleme können auftreten, wenn der Broadcast-Austausch des dynamischen Bereinigungsfilters zu unterschiedlichen, inkonsistenten Ergebnissen führt, als der Broadcast-Austausch des entsprechenden Join-Vorgangs. Das Einstellen dieser Konfiguration auf `false` sollte mit Vorsicht erfolgen. Dadurch können Szenarien umgangen werden, z. B. wenn die Wiederverwendung durch benutzerdefinierte Spaltenregeln gestört wird. Wenn Adaptive Abfrageausführung aktiviert ist, wird die Wiederverwendung von Broadcasts immer erzwungen. |
Diese Optimierung verbessert die vorhandenen Funktionen von Spark 2.4.2, das nur die Weitergabe statischer Prädikate unterstützt, um diese zu geplanten Zeiten aufzulösen.
Im Folgenden finden Sie Beispiele für die Weitergabe statischer Prädikate in Sparke 2.4.2.
```
partition_col = 5
partition_col IN (1,3,5)
partition_col between 1 and 3
partition_col = 1 + 3
```
Die dynamische Partitionsbereinigung ermöglicht es der Spark-Engine, während der Laufzeit dynamisch abzuleiten, welche Partitionen gelesen werden müssen und welche problemlos eliminiert werden können. Die folgende Abfrage beinhaltet beispielsweise zwei Tabellen: die Tabelle `store_sales`, die den Gesamtumsatz aller Geschäfte enthält und nach Regionen partitioniert ist, sowie die Tabelle `store_regions`, die für die einzelnen Länder eine Zuweisung nach Regionen enthält. Die Tabellen enthalten Daten für Geschäfte, die auf der ganzen Welt verteilt sind, allerdings benötigen wir nur die Daten für Nordamerika.
```
select ss.quarter, ss.region, ss.store, ss.total_sales
from store_sales ss, store_regions sr
where ss.region = sr.region and sr.country = 'North America'
```
Ohne die dynamische Partitionsbereinigung, liest diese Anfrage alle Regionen, bevor Sie die Untergruppe an Regionen herausfiltert, die mit den Ergebnissen der Unterabfrage übereinstimmen. Mit der dynamischen Partitionsbereinigung liest und verarbeitet diese Abfrage nur die Partitionen für die Regionen, die in der Unterabfrage zurückgegeben wurden. Da weniger Daten im Speicher gelesen und weniger Datensätze verarbeitet werden müssen, spart dies Zeit und Ressourcen.
## Abflachen skalarer Unterabfragen
Diese Optimierung verbessert die Leistung von Abfragen, die in der gleichen Tabelle skalare Unterabfragen ausführen. In Amazon EMR 5.26.0 ist dieses Feature standardmäßig aktiviert. In Amazon EMR 5.24.0 und 5.25.0 können Sie es aktivieren, indem Sie die Spark-Eigenschaft `spark.sql.optimizer.flattenScalarSubqueriesWithAggregates.enabled` innerhalb von Spark oder beim Erstellen von Clustern festlegen. Wenn diese Eigenschaft auf „true“ festgelegt ist, flacht der Abfrageoptimierer aggregierte skalare Unterabfragen, die, wenn möglich, dieselbe Relation verwenden, ab. Die skalaren Unterabfragen werden abgeflacht, indem alle in der Unterabfrage vorhandenen Prädikate an die Aggregationsfunktionen weitergegeben werden. Im Anschluss daran wird pro Relation eine Aggregation mit allen Aggregatfunktionen ausgeführt.
Im Folgenden finden Sie ein Beispiel für eine Abfrage, die von dieser Optimierung profitiert.
```
select (select avg(age) from students /* Subquery 1 */
where age between 5 and 10) as group1,
(select avg(age) from students /* Subquery 2 */
where age between 10 and 15) as group2,
(select avg(age) from students /* Subquery 3 */
where age between 15 and 20) as group3
```
Die Optimierung schreibt die vorherige Abfrage folgendermaßen um:
```
select c1 as group1, c2 as group2, c3 as group3
from (select avg (if(age between 5 and 10, age, null)) as c1,
avg (if(age between 10 and 15, age, null)) as c2,
avg (if(age between 15 and 20, age, null)) as c3 from students);
```
Beachten Sie, dass die umgeschriebene Abfrage die Studententabelle nur einmal liest und die Prädikate der drei Unterabfragen per Push-Verfahren in die `avg`-Funktion weitergegeben werden.
## DISTINCT vor INTERSECT
Diese Optimierung verbessert Joins, wenn INTERSECT verwendet wird. In Amazon EMR 5.26.0 ist dieses Feature standardmäßig aktiviert. In Amazon EMR 5.24.0 und 5.25.0 können Sie es aktivieren, indem Sie die Spark-Eigenschaft `spark.sql.optimizer.distinctBeforeIntersect.enabled` innerhalb von Spark oder beim Erstellen von Clustern festlegen. Abfragen mit INTERSECT werden automatisch so konvertiert, dass sie einen linken halben Join verwenden. Wenn diese Eigenschaft auf true gesetzt ist, überträgt der Abfrageoptimierer den DISTINCT-Operator an die untergeordneten Objekte von INTERSECT, wenn er feststellt, dass der DISTINCT-Operator die linke Semi-Verknüpfung zu einem statt zu a machen kann. BroadcastHashJoin SortMergeJoin
Im Folgenden finden Sie ein Beispiel für eine Abfrage, die von dieser Optimierung profitiert.
```
(select item.brand brand from store_sales, item
where store_sales.item_id = item.item_id)
intersect
(select item.brand cs_brand from catalog_sales, item
where catalog_sales.item_id = item.item_id)
```
Wenn die Eigenschaft `spark.sql.optimizer.distinctBeforeIntersect.enabled`, nicht aktiviert ist, wird die Abfrage folgendermaßen neu geschrieben.
```
select distinct brand from
(select item.brand brand from store_sales, item
where store_sales.item_id = item.item_id)
left semi join
(select item.brand cs_brand from catalog_sales, item
where catalog_sales.item_id = item.item_id)
on brand <=> cs_brand
```
Wenn die Eigenschaft `spark.sql.optimizer.distinctBeforeIntersect.enabled`, nicht aktiviert ist, wird die Abfrage folgendermaßen neu geschrieben.
```
select brand from
(select distinct item.brand brand from store_sales, item
where store_sales.item_id = item.item_id)
left semi join
(select distinct item.brand cs_brand from catalog_sales, item
where catalog_sales.item_id = item.item_id)
on brand <=> cs_brand
```
## Bloomfilter für Joins
Durch diese Optimierung kann die Leistung einiger Joins verbessert werden, da eine Seite eines Joins mit einem [Bloomfilter](https://en.wikipedia.org/wiki/Bloom_filter) vorgefiltert wird, der aus den Werten von der anderen Seite des Joins generiert wird. In Amazon EMR 5.26.0 ist dieses Feature standardmäßig aktiviert. In Amazon EMR 5.25.0 können Sie dieses Feature aktivieren, indem Sie die Spark-Eigenschaft `spark.sql.bloomFilterJoin.enabled` innerhalb von Spark oder beim Erstellen von Clustern auf `true` setzen.
Im Folgenden finden Sie eine Beispielabfrage, für die die Anwendung eines Bloomfilters geeignet wäre.
```
select count(*)
from sales, item
where sales.item_id = item.id
and item.category in (1, 10, 16)
```
Wenn diese Funktion aktiviert ist, wird der Bloomfilter aus allen Artikel-IDs erstellt, deren Kategorie sich innerhalb des Kategoriensatzes befindet, der abgefragt wird. Beim Scannen der Tabelle SALES wird der Bloomfilter verwendet, um zu ermitteln, welche Verkäufe für Artikel gelten, die sich definitiv nicht im vom Bloomfilter definierten Satz befinden. So können diese ermittelten Verkäufe so früh wie möglich herausgefiltert werden.
## Optimierte Join-Neuanordnung
Durch diese Optimierung kann die Abfrageleistung verbessert werden, indem bei Tabellen mit Filtern die Joins neu angeordnet werden. In Amazon EMR 5.26.0 ist dieses Feature standardmäßig aktiviert. In Amazon EMR 5.25.0, können Sie dieses Feature aktivieren, indem Sie den Spark-Konfigurationsparameter `spark.sql.optimizer.sizeBasedJoinReorder.enabled` auf „wahr“ setzen. Das Standardverhalten von Spark ist, dass Tabellen von links nach rechts verknüpft werden, wie in der Abfrage aufgeführt. Dabei kann die Chance verpasst werden, zuerst kleinere Joins mit Filtern auszuführen, was später teureren Joins zugute kommen würde.
Bei der Beispielabfrage unten werden alle zurückgegebenen Artikel aus allen Läden in einem Land ausgewertet. Ohne optimierte Join-Neuanordnung verknüpft Spark zuerst die zwei großen Tabellen `store_sales` und `store_returns` und verknüpft sie dann mit `store` und schließlich mit `item`.
```
select ss.item_value, sr.return_date, s.name, i.desc,
from store_sales ss, store_returns sr, store s, item i
where ss.id = sr.id and ss.store_id = s.id and ss.item_id = i.id
and s.country = 'USA'
```
Bei der optimierten Join-Neuanordnung verknüpft Spark zuerst `store_sales` mit `store`, da `store` über einen Filter verfügt und kleiner ist als `store_returns` und `broadcastable`. Danach führt Spark einen Join mit `store_returns` und schließlich mit `item` durch. Wenn `item` über einen Filter verfügen würde und sendungsfähig wäre, würde es sich ebenfalls für die Neuanordnung eignen, was dazu führen würde, dass `store_sales` mit `store`, dann mit `item` und schließlich mit `store_returns` verknüpft würde.
# Caching von Ergebnisfragmenten in Spark
Amazon EMR 6.6.0 und höher enthalten das optionale Feature zum Caching von Ergebnisfragmenten in Spark, mit dem Ergebnisfragmente automatisch zwischengespeichert werden. Diese Ergebnisfragmente sind Teile von Ergebnissen aus Teilbäumen von Abfragen, die in einem Amazon-S3-Bucket Ihrer Wahl gespeichert sind. Die gespeicherten Fragmente der Abfrageergebnisse werden bei nachfolgenden Abfrageausführungen wiederverwendet, was zu schnelleren Abfragen führt.
Beim Zwischenspeichern von Ergebnisfragmenten werden Ihre Spark-Abfragen analysiert und geeignete Ergebnisfragmente an Ihrem angegebenen S3-Speicherort zwischengespeichert. Bei nachfolgenden Abfrageläufen werden die verwendbaren Fragmente der Abfrageergebnisse automatisch erkannt und von S3 abgerufen. Das Caching von Ergebnisfragmenten unterscheidet sich vom Zwischenspeichern von Ergebnismengen, bei dem nachfolgende Abfragen exakt mit der ursprünglichen Abfrage übereinstimmen müssen, um Ergebnisse aus dem Cache zurückzugeben. Wenn es für Abfragen verwendet wird, die wiederholt auf eine statische Teilmenge Ihrer Daten abzielen, beschleunigt das Caching von Ergebnisfragmenten die Leistung erheblich.
Stellen Sie sich die folgende Abfrage vor, die Bestellungen bis zum Jahr 2022 zählt:
```
select
l_returnflag,
l_linestatus,
count(*) as count_order
from
lineitem
where
l_shipdate <= current_date
and year(l_shipdate) == '2022'
group by
l_returnflag,
l_linestatus
```
Im Laufe der Zeit muss diese Abfrage täglich ausgeführt werden, um den Gesamtumsatz des Jahres zu melden. Ohne das Caching von Ergebnisfragmenten müssen die Ergebnisse für alle Tage des Jahres täglich neu berechnet werden. Die Abfrage wird mit der Zeit langsamer und am Jahresende, wenn die Ergebnisse aller 365 Tage neu berechnet werden müssen, am langsamsten.
Wenn Sie das Caching von Ergebnisfragmenten aktivieren, verwenden Sie Ergebnisse für alle vorherigen Tage des Jahres aus dem Cache. An jedem Tag muss das Feature nur die Ergebnisse eines Tages neu berechnen. Nachdem das Feature das Ergebnisfragment berechnet hat, speichert das Feature das Fragment im Cache. Dadurch sind die Cache-aktivierten Abfragezeiten schnell und sie bleiben bei jeder nachfolgenden Abfrage konstant.
## Caching von Ergebnisfragmenten in Spark aktivieren
Zum Aktivieren von Caching von Ergebnisfragmenten in Spark führen Sie die folgenden Schritte durch:
1. Erstellen Sie einen Cache-Bucket in Amazon S3 und autorisieren Sie read/write den Zugriff für EMRFS. Weitere Informationen finden Sie unter [Zugriff auf EMRFS-Daten in Amazon S3 genehmigen](emr-plan-credentialsprovider.md).
1. Stellen Sie die Amazon-EMR-Spark-Konfiguration ein, um das Feature zu aktivieren.
```
spark.subResultCache.enabled = true
spark.subResultCache.fs.root.path = s3://&example-s3-bucket;/cache_dir/
```
1. Aktivieren Sie das S3-Lebenszyklusmanagement für den Bucket, um Cache-Dateien automatisch zu bereinigen.
1. Optional können Sie die maxBufferSize Eigenschaften reductionRationThreshold und konfigurieren, um die Funktion weiter zu optimieren.
```
spark.sql.subResultCache.reductionRatioThreshold
spark.sql.subResultCache.maxBufferSize
```
## Einige Hinweise zur Verwendung von Caching von Ergebnisfragmenten
Die Kosteneinsparungen, wenn Sie Ergebnisse verwenden, die bereits in Amazon S3 zwischengespeichert wurden, anstatt sie neu zu berechnen, steigen mit der Häufigkeit, mit der dieselben zwischengespeicherten Ergebnisse verwendet werden können. Abfragen mit umfangreichen Tabellenscans, gefolgt von Filtern oder Hash-Aggregationen, die die Ergebnisgröße um den Faktor 8 reduzieren (d. h. ein Verhältnis von mindestens 8:1 bei Eingabegröße zu Ergebnissen), profitieren am meisten von dieses Features. Je größer das Reduktionsverhältnis zwischen Eingabe und Ergebnissen ist, desto größer ist der Kostenvorteil. Abfragen mit kleineren Reduktionsraten, die jedoch teure Rechenschritte zwischen dem Tabellenscan und Filtern oder Aggregationen enthalten, werden ebenfalls davon profitieren, sofern die Kosten für die Erstellung der Ergebnisse höher sind als die Kosten für das Abrufen der Ergebnisse aus Amazon S3. Standardmäßig wird das Caching von Ergebnisfragmenten nur wirksam, wenn erkannt wird, dass das Reduktionsverhältnis mindestens 8:1 beträgt.
Wenn Ihre Abfragen zwischengespeicherte Ergebnisse wiederholt wiederverwenden, sind die Vorteile dieses Features am größten. Rollende und inkrementelle Fensterabfragen sind gute Beispiele. Beispielsweise müsste bei einer 30-tägigen rollenden Fenster-Abfrage, die bereits 29 Tage lang ausgeführt wurde, nur 1/30 der Zieldaten aus der ursprünglichen Eingabequelle abgerufen werden, und es würden zwischengespeicherte Ergebnisfragmente für die 29 vorherigen Tage verwendet. Eine inkrementelle Fensterabfrage wäre sogar noch besser, da der Beginn des Fensters unverändert bleibt: Bei jedem Aufruf der Abfrage muss ein kleinerer Prozentsatz der Verarbeitung aus der Eingabequelle gelesen werden.
Im Folgenden finden Sie weitere Überlegungen zur Verwendung von Caching von Ergebnisfragmenten:
+ Abfragen, die nicht auf dieselben Daten mit denselben Abfragefragmenten abzielen, haben eine niedrige Cache-Trefferrate und profitieren daher nicht von diesem Feature.
+ Abfragen mit niedrigen Reduktionsraten, die keine teuren Rechenschritte enthalten, führen zu zwischengespeicherten Ergebnissen, deren Lesen ungefähr so teuer ist wie die ursprüngliche Verarbeitung.
+ Die erste Abfrage weist aufgrund der Kosten für das Schreiben in den Cache immer eine geringfügige Regression auf.
+ Das Feature zum Caching von Ergebnisfragmenten funktioniert ausschließlich mit Parquet-Dateien. Andere Dateiformate werden nicht unterstützt.
+ Das Feature Caching von Ergebnisfragmenten für das Zwischenspeichern von Ergebnisfragmenten versucht nur, Scans mit Datei-Split-Größen von 128 MB oder mehr zwischenzuspeichern. Bei der Standardkonfiguration von Spark ist das Caching von Ergebnisfragmenten deaktiviert, wenn die Scangröße (Gesamtgröße aller gescannten Dateien) geteilt durch die Anzahl der Executor-Cores weniger als 128 MB beträgt. Wenn eine der unten aufgeführten Spark-Konfigurationen festgelegt ist, beträgt die Größe der aufgeteilten Datei:
```
min(maxPartitionBytes, max(openCostInBytes, scan size / minPartitionNum))
```
+ spark.sql. leafNodeDefaultParallelismus (Standardwert ist spark.default.parallelism)
+ spark.sql.files. minPartitionNum (Der Standardwert ist spark.sql. leafNodeDefaultParallelität)
+ spark.sql.files. openCostInByte
+ spark.sql.dateien. maxPartitionBytes
+ Das Feature zum Caching von Ergebnisfragmenten speichert die Granularität der RDD-Partition im Cache. Das zuvor beschriebene Reduktionsverhältnis, das standardmäßig 8:1 beträgt, wird pro RDD-Partition bewertet. Bei Workloads mit Reduktionsraten pro RDD, die sowohl größer als auch kleiner als 8:1 sind, kann es zu geringeren Leistungsvorteilen kommen als bei Workloads mit Reduktionsraten pro RDD, die durchweg unter 8:1 liegen.
+ Das Feature zum Caching von Ergebnisfragmenten verwendet standardmäßig einen Schreibpuffer von 16 MB für jede RDD-Partition, die zwischengespeichert wird. Wenn mehr als 16 MB pro RDD-Partition zwischengespeichert werden, können die Kosten für die Feststellung, dass kein Schreibvorgang möglich ist, zu Leistungsregressionen führen.
+ Standardmäßig versucht Caching von Ergebnisfragmenten zwar nicht, Ergebnisse einer RDD-Partition mit einem Reduktionsverhältnis von weniger als 8:1 zwischenzuspeichern und seinen Schreibpuffer auf 16 MB begrenzt, aber beide Werte können über die folgenden Konfigurationen eingestellt werden:
```
spark.sql.subResultCache.reductionRatioThreshold (default: 8.0)
spark.sql.subResultCache.maxBufferSize (default: 16MB, max: 64MB)
```
+ Mehrere Cluster, die dieselbe Amazon-EMR-Version verwenden, können sich denselben Cache-Speicherort teilen. Um die Richtigkeit der Ergebnisse sicherzustellen, verwendet Caching von Ergebnisfragmenten keine Cache-Ergebnisse, die von verschiedenen Versionen von Amazon EMR geschrieben wurden.
+ Das Zwischenspeichern von Ergebnisfragmenten wird automatisch für Spark Streaming-Anwendungsfälle deaktiviert oder wenn RecordServer Apache Ranger oder verwendet AWS Lake Formation wird.
+ Der Ergebnisfragment-Cache read/writes verwendet EMRFS/S3A- und Amazon S3 S3-Buckets. CSE (nur mit EMRFS)/SSE S3/SSE KMS-Verschlüsselung wird unterstützt. Zum besseren Verständnis bietet S3A eine Hadoop-Implementierung, mit der ein Cluster Daten in und aus Amazon S3 lesen und schreiben kann. Beachten Sie, dass Unterstützung für S3A mit EMR-7.4.0 und höher verfügbar ist.
# Den Nvidia-RAPIDS-Accelerator für Apache Spark verwenden
Mit Amazon-EMR-Version 6.2.0 und höher können Sie das Plugin [RAPIDS Accelerator für Apache Spark](https://docs.nvidia.com/spark-rapids/user-guide/latest/overview.html) von Nvidia verwenden, um Spark mithilfe von EC2-GPU (Graphics Processing Unit)-Instance-Typen zu beschleunigen. RAPIDS Accelerator beschleunigt Ihre Apache-Spark-3.0-Pipelines für die Datenwissenschaft ohne Codeänderungen mit der GPU, beschleunigt die Datenverarbeitung und das Modelltraining und senkt gleichzeitig die Infrastrukturkosten erheblich.
Die folgenden Abschnitte führen Sie durch die Konfiguration Ihres EMR-Clusters für die Verwendung des Spark-Rapids-Plugins für Spark.
## Instance-Typen auswählen
Um das Nvidia-Spark-RAPIDS-Plugin für Spark verwenden zu können, müssen die Kern- und Aufgaben-Instance-Gruppen EC2-GPU-Instance-Typen verwenden, die die [Hardwareanforderungen von Spark-RAPIDS](https://nvidia.github.io/spark-rapids/) erfüllen. Eine vollständige Liste der von Amazon EMR unterstützten GPU-Instance-Typen finden Sie unter [Unterstützte Instance-Typen](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-supported-instance-types.html) im *Verwaltungshandbuch für Amazon EMR*. Der Instance-Typ für die primäre Instance-Gruppe kann entweder GPU- oder Nicht-GPU-Typen sein, ARM-Instance-Typen werden jedoch nicht unterstützt.
## Anwendungskonfigurationen für Ihren Cluster einrichten
**1. Amazon EMR aktivieren, um die Plugins auf Ihrem neuen Cluster zu installieren**
Zum Installieren von Plugins geben Sie beim Erstellen Ihres Clusters die folgende Konfiguration an:
```
{
"Classification":"spark",
"Properties":{
"enableSparkRapids":"true"
}
}
```
**2. YARN für die Verwendung von GPU konfigurieren**
Einzelheiten zur Verwendung von GPU auf YARN finden Sie unter [Verwenden von GPU auf YARN](https://hadoop.apache.org/docs/r3.2.1/hadoop-yarn/hadoop-yarn-site/UsingGpus.html) in der Apache-Hadoop-Dokumentation. Die folgenden Beispiele zeigen YARN-Beispielkonfigurationen für die Amazon-EMR-Versionen 6.x und 7.x:
------
#### [ Amazon EMR 7.x ]
**Beispiel für eine YARN-Konfiguration für Amazon EMR 7.x**
```
{
"Classification":"yarn-site",
"Properties":{
"yarn.nodemanager.resource-plugins":"yarn.io/gpu",
"yarn.resource-types":"yarn.io/gpu",
"yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
"yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
"yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
"yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/spark-rapids-cgroup",
"yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
"yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
}
},{
"Classification":"container-executor",
"Properties":{
},
"Configurations":[
{
"Classification":"gpu",
"Properties":{
"module.enabled":"true"
}
},
{
"Classification":"cgroups",
"Properties":{
"root":"/spark-rapids-cgroup",
"yarn-hierarchy":"yarn"
}
}
]
}
```
------
#### [ Amazon EMR 6.x ]
**Beispiel für eine YARN-Konfiguration für Amazon EMR 6.x**
```
{
"Classification":"yarn-site",
"Properties":{
"yarn.nodemanager.resource-plugins":"yarn.io/gpu",
"yarn.resource-types":"yarn.io/gpu",
"yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
"yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
"yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
"yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/sys/fs/cgroup",
"yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
"yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
}
},{
"Classification":"container-executor",
"Properties":{
},
"Configurations":[
{
"Classification":"gpu",
"Properties":{
"module.enabled":"true"
}
},
{
"Classification":"cgroups",
"Properties":{
"root":"/sys/fs/cgroup",
"yarn-hierarchy":"yarn"
}
}
]
}
```
------
**3. Spark für die Verwendung von RAPIDS konfigurieren**
Hier sind die erforderlichen Konfigurationen, damit Spark das RAPIDS-Plugin verwenden kann:
```
{
"Classification":"spark-defaults",
"Properties":{
"spark.plugins":"com.nvidia.spark.SQLPlugin",
"spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh",
"spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native"
}
}
```
XGBoost4Die [J-Spark-Bibliothek](https://xgboost.readthedocs.io/en/latest/jvm/xgboost4j_spark_tutorial.html) in der XGBoost Dokumentation ist auch verfügbar, wenn das Spark RAPIDS-Plugin auf Ihrem Cluster aktiviert ist. Sie können die folgende Konfiguration für die Integration in XGBoost Ihren Spark-Job verwenden:
```
{
"Classification":"spark-defaults",
"Properties":{
"spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar"
}
}
```
Weitere Spark-Konfigurationen, mit denen Sie einen GPU-beschleunigten EMR-Cluster optimieren können, finden Sie im [Accelerator für Apache-Spark-Tuning-Anleitung](https://docs.nvidia.com/spark-rapids/user-guide/latest/tuning-guide.html) in der Nvidia.github.io-Dokumentation.
**4. YARN Capacity Scheduler konfigurieren**
`DominantResourceCalculator` muss so konfiguriert sein, dass GPU-Planung und -Isolierung aktiviert werden. Weitere Informationen finden Sie unter [Verwendung der GPU auf YARN](https://hadoop.apache.org/docs/r3.2.1/hadoop-yarn/hadoop-yarn-site/UsingGpus.html) in der Apache-Hadoop-Dokumentation.
```
{
"Classification":"capacity-scheduler",
"Properties":{
"yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator"
}
}
```
**5. Eine JSON-Datei erstellen, die all Ihre Konfigurationen enthält**
Sie können eine JSON-Datei erstellen, die Ihre Konfiguration für die Verwendung des RAPIDS-Plugins für Ihren Spark-Cluster enthält. Sie stellen die Datei später bereit, wenn Sie Ihren Cluster starten.
Sie können die Datei lokal oder in S3 speichern. Weitere Informationen zur Bereitstellung von Anwendungskonfigurationen für Ihre Cluster finden Sie unter [Anwendungen konfigurieren](emr-configure-apps.md).
Verwenden Sie die folgenden Beispieldateien als Vorlagen, um Ihre eigenen Konfigurationen zu erstellen.
------
#### [ Amazon EMR 7.x ]
**`my-configurations.json`-Beispieldatei für Amazon EMR 7.x**
```
[
{
"Classification":"spark",
"Properties":{
"enableSparkRapids":"true"
}
},
{
"Classification":"yarn-site",
"Properties":{
"yarn.nodemanager.resource-plugins":"yarn.io/gpu",
"yarn.resource-types":"yarn.io/gpu",
"yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
"yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
"yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
"yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/spark-rapids-cgroup",
"yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
"yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
}
},
{
"Classification":"container-executor",
"Properties":{
},
"Configurations":[
{
"Classification":"gpu",
"Properties":{
"module.enabled":"true"
}
},
{
"Classification":"cgroups",
"Properties":{
"root":"/spark-rapids-cgroup",
"yarn-hierarchy":"yarn"
}
}
]
},
{
"Classification":"spark-defaults",
"Properties":{
"spark.plugins":"com.nvidia.spark.SQLPlugin",
"spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh",
"spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native",
"spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar",
"spark.rapids.sql.concurrentGpuTasks":"1",
"spark.executor.resource.gpu.amount":"1",
"spark.executor.cores":"2",
"spark.task.cpus":"1",
"spark.task.resource.gpu.amount":"0.5",
"spark.rapids.memory.pinnedPool.size":"0",
"spark.executor.memoryOverhead":"2G",
"spark.locality.wait":"0s",
"spark.sql.shuffle.partitions":"200",
"spark.sql.files.maxPartitionBytes":"512m"
}
},
{
"Classification":"capacity-scheduler",
"Properties":{
"yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator"
}
}
]
```
------
#### [ Amazon EMR 6.x ]
**`my-configurations.json`-Beispieldatei für Amazon EMR 6.x**
```
[
{
"Classification":"spark",
"Properties":{
"enableSparkRapids":"true"
}
},
{
"Classification":"yarn-site",
"Properties":{
"yarn.nodemanager.resource-plugins":"yarn.io/gpu",
"yarn.resource-types":"yarn.io/gpu",
"yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
"yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
"yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
"yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/sys/fs/cgroup",
"yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
"yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
}
},
{
"Classification":"container-executor",
"Properties":{
},
"Configurations":[
{
"Classification":"gpu",
"Properties":{
"module.enabled":"true"
}
},
{
"Classification":"cgroups",
"Properties":{
"root":"/sys/fs/cgroup",
"yarn-hierarchy":"yarn"
}
}
]
},
{
"Classification":"spark-defaults",
"Properties":{
"spark.plugins":"com.nvidia.spark.SQLPlugin",
"spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh",
"spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native",
"spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar",
"spark.rapids.sql.concurrentGpuTasks":"1",
"spark.executor.resource.gpu.amount":"1",
"spark.executor.cores":"2",
"spark.task.cpus":"1",
"spark.task.resource.gpu.amount":"0.5",
"spark.rapids.memory.pinnedPool.size":"0",
"spark.executor.memoryOverhead":"2G",
"spark.locality.wait":"0s",
"spark.sql.shuffle.partitions":"200",
"spark.sql.files.maxPartitionBytes":"512m"
}
},
{
"Classification":"capacity-scheduler",
"Properties":{
"yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator"
}
}
]
```
------
## Fügen Sie eine Bootstrap-Aktion für Ihren Cluster hinzu
Weitere Informationen zur Bereitstellung von Bootstrap-Aktionsskripten bei der Erstellung Ihres Clusters finden Sie unter [Grundlagen der Bootstrap-Aktion](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-bootstrap.html#bootstrapUses) im *Verwaltungshandbuch für Amazon EMR*.
Die folgenden Beispielskripts zeigen, wie eine Bootstrap-Aktionsdatei für Amazon EMR 6.x und 7.x erstellt wird:
------
#### [ Amazon EMR 7.x ]
**`my-bootstrap-action.sh`-Beispieldatei für Amazon EMR 7.x**
Um YARN zur Verwaltung von GPU-Ressourcen mit Amazon-EMR-7.x-Versionen zu verwenden, müssen Sie sie CGroup v1 manuell auf Ihrem Cluster bereitstellen. Sie können dies mit einem Bootstrap-Aktionsskript tun, wie in diesem Beispiel gezeigt.
```
#!/bin/bash
set -ex
sudo mkdir -p /spark-rapids-cgroup/devices
sudo mount -t cgroup -o devices cgroupv1-devices /spark-rapids-cgroup/devices
sudo chmod a+rwx -R /spark-rapids-cgroup
```
------
#### [ Amazon EMR 6.x ]
**`my-bootstrap-action.sh`-Beispieldatei für Amazon EMR 6.x**
Für Amazon-EMR-6.x-Versionen müssen Sie CGroup-Berechtigungen für YARN in Ihrem Cluster öffnen. Sie können dies mit einem Bootstrap-Aktionsskript tun, wie in diesem Beispiel gezeigt.
```
#!/bin/bash
set -ex
sudo chmod a+rwx -R /sys/fs/cgroup/cpu,cpuacct
sudo chmod a+rwx -R /sys/fs/cgroup/devices
```
------
## Ihren Cluster starten
Der letzte Schritt besteht darin, Ihren Cluster mit den oben genannten Cluster-Konfigurationen zu starten. Hier ist ein Beispielbefehl zum Starten eines Clusters über die Amazon-EMR-CLI:
```
aws emr create-cluster \
--release-label emr-7.12.0 \
--applications Name=Hadoop Name=Spark \
--service-role EMR_DefaultRole_V2 \
--ec2-attributes KeyName=my-key-pair,InstanceProfile=EMR_EC2_DefaultRole \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.4xlarge \
InstanceGroupType=CORE,InstanceCount=1,InstanceType=g4dn.2xlarge \
InstanceGroupType=TASK,InstanceCount=1,InstanceType=g4dn.2xlarge \
--configurations file:///my-configurations.json \
--bootstrap-actions Name='My Spark Rapids Bootstrap action',Path=s3://amzn-s3-demo-bucket/my-bootstrap-action.sh
```
# Zugriff auf die Spark-Shell
Die Spark-Shell basiert auf dem Scala REPL (Read-Eval-Print-Loop). Damit können Sie Spark-Programme interaktiv erstellen und Arbeit an das Framework senden. Sie können auf die Spark-Shell zugreifen, indem Sie eine Verbindung mit dem Primärknoten über SSH herstellen und `spark-shell` aufrufen. Weitere Informationen zum Herstellen einer Verbindung mit dem Primärknoten finden Sie unter [Verbinden mit dem Primärknoten über SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) im *Verwaltungshandbuch für Amazon EMR*. In den folgenden Beispielen werden Apache-HTTP-Serverzugriffsprotokolle in Amazon S3 verwendet.
**Anmerkung**
Der Bucket in diesen Beispielen ist für Clients mit Zugriff auf USA Ost (Nord-Virginia) verfügbar.
Standardmäßig erstellt die Spark-Shell ihr eigenes [SparkContext](https://spark.apache.org/docs/1.3.1/api/scala/index.html#org.apache.spark.SparkContext)Objekt namens`sc`. Sie können diesen Kontext verwenden, wenn er in der REPL erforderlich ist. sqlContextist auch in der Shell verfügbar und es ist ein [HiveContext](https://spark.apache.org/docs/latest/api/scala/index.html#org.apache.spark.sql.hive.HiveContext).
**Example Verwenden Sie die Spark-Shell, um die Vorkommen einer Zeichenkette in einer in Amazon S3 gespeicherten Datei zu zählen**
Dieses Beispiel verwendet `sc` zum Lesen einer Textdatei in Amazon S3.
```
scala> sc
res0: org.apache.spark.SparkContext = org.apache.spark.SparkContext@404721db
scala> val textFile = sc.textFile("s3://elasticmapreduce/samples/hive-ads/tables/impressions/dt=2009-04-13-08-05/ec2-0-51-75-39.amazon.com.rproxy.govskope.ca-2009-04-13-08-05.log")
```
Spark erstellt die Datei „textFile“ und die zugehörige [-Datenstruktur](https://spark.apache.org/docs/latest/programming-guide.html#resilient-distributed-datasets-rdds). Im Beispiel wird dann die Anzahl der Zeilen in der Protokolldatei mit der Zeichenfolge "cartoonnetwork.com" gezählt:
```
scala> val linesWithCartoonNetwork = textFile.filter(line => line.contains("cartoonnetwork.com")).count()
linesWithCartoonNetwork: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[2] at filter at :23
scala> linesWithCartoonNetwork
res2: Long = 9
```
**Example Verwenden Sie die Python-basierte Spark-Shell, um die Vorkommen einer Zeichenkette in einer in Amazon S3 gespeicherten Datei zu zählen**
Spark umfasst auch eine auf Python basierende Shell, `pyspark`, mit der Sie Prototypen von in Python geschriebenen Spark-Programmen entwickeln können. Genau wie bei`spark-shell`, `pyspark` auf dem Primärknoten aufrufen; es hat auch dasselbe [SparkContext](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkContext.html#pyspark.SparkContext)Objekt.
```
>>> sc
>>> textfile = sc.textFile("s3://elasticmapreduce/samples/hive-ads/tables/impressions/dt=2009-04-13-08-05/ec2-0-51-75-39.amazon.com.rproxy.govskope.ca-2009-04-13-08-05.log")
```
Spark erstellt die Datei „textFile“ und die zugehörige [-Datenstruktur](https://spark.apache.org/docs/latest/programming-guide.html#resilient-distributed-datasets-rdds). Im Beispiel wird dann die Anzahl der Zeilen in der Protokolldatei mit der Zeichenfolge "cartoonnetwork.com" gezählt.
```
>>> linesWithCartoonNetwork = textfile.filter(lambda line: "cartoonnetwork.com" in line).count()
15/06/04 17:12:22 INFO lzo.GPLNativeCodeLoader: Loaded native gpl library from the embedded binaries
15/06/04 17:12:22 INFO lzo.LzoCodec: Successfully loaded & initialized native-lzo library [hadoop-lzo rev EXAMPLE]
15/06/04 17:12:23 INFO fs.EmrFileSystem: Consistency disabled, using com.amazon.ws.emr.hadoop.fs.s3n.S3NativeFileSystem as filesystem implementation
>>> linesWithCartoonNetwork
9
```
# Verwenden Sie Amazon SageMaker Spark für maschinelles Lernen
Bei der Verwendung von Amazon-EMR-Version 5.11.0 und höher wird die `aws-sagemaker-spark-sdk`-Komponente zusammen mit Spark installiert. Diese Komponente installiert Amazon SageMaker Spark und die zugehörigen Abhängigkeiten für die Spark-Integration mit [Amazon SageMaker](https://aws.amazon.com/sagemaker/). Bitte beachten Sie, dass die `aws-sagemaker-spark-sdk` Komponente ab Amazon EMR 7.x und höher nicht verfügbar ist. Sie können Amazon SageMaker Spark verwenden, um Spark-Pipelines für maschinelles Lernen (ML) mithilfe von SageMaker Amazon-Stufen zu erstellen. Weitere Informationen finden Sie in der [Amazon SageMaker Spark-README-Datei](https://github.com/aws/sagemaker-spark/blob/master/README.md) zu Apache Spark GitHub und zur [Verwendung von Apache Spark mit Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/apache-spark.html) im *Amazon SageMaker Developer Guide*.
# Eine Spark-Anwendung schreiben
[Spark](https://aws.amazon.com/big-data/what-is-spark/)-Anwendungen können in Scala, Java und Python geschrieben werden. In der Dokumentation zu Apache Stark finden Sie im Thema [Spark-Beispiele](https://spark.apache.org/examples.html) einige Beispiele für Spark-Anwendungen. Das Beispiel zum Schätzen von Pi, "Estimating Pi", ist unten in den drei nativ unterstützten Anwendungen dargestellt. Vollständige Beispiele finden Sie auch unter `$SPARK_HOME/examples` und unter [GitHub](https://github.com/apache/spark/tree/master/examples/src/main). Weitere Informationen darüber, wie man JARs für Spark baut, finden Sie im Thema [Schnellstart](https://spark.apache.org/docs/latest/quick-start.html) in der Apache Spark-Dokumentation.
## Scala
Um Scala-Kompatibilitätsprobleme zu vermeiden, empfehlen wir, Spark-Abhängigkeiten für die richtige Scala-Version zu verwenden, wenn Sie eine Spark-Anwendung für einen Amazon-EMR-Cluster kompilieren. Welche Scala-Version Sie verwenden sollten, hängt von der Version von Spark ab, die auf Ihrem Cluster installiert ist. Amazon-EMR-Version 5.30.1 verwendet beispielsweise Spark 2.4.5, das mit Scala 2.11 erstellt wurde. Wenn Ihr Cluster Amazon-EMR-Version 5.30.1 verwendet, verwenden Sie Spark-Abhängigkeiten für Scala 2.11. Weitere Informationen zu den von Spark verwendeten Scala-Versionen finden Sie in der [Apache-Spark-Dokumentation.](https://spark.apache.org/documentation.html)
```
package org.apache.spark.examples
import scala.math.random
import org.apache.spark._
/** Computes an approximation to pi */
object SparkPi {
def main(args: Array[String]) {
val conf = new SparkConf().setAppName("Spark Pi")
val spark = new SparkContext(conf)
val slices = if (args.length > 0) args(0).toInt else 2
val n = math.min(100000L * slices, Int.MaxValue).toInt // avoid overflow
val count = spark.parallelize(1 until n, slices).map { i =>
val x = random * 2 - 1
val y = random * 2 - 1
if (x*x + y*y < 1) 1 else 0
}.reduce(_ + _)
println("Pi is roughly " + 4.0 * count / n)
spark.stop()
}
}
```
## Java
```
package org.apache.spark.examples;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import java.util.ArrayList;
import java.util.List;
/**
* Computes an approximation to pi
* Usage: JavaSparkPi [slices]
*/
public final class JavaSparkPi {
public static void main(String[] args) throws Exception {
SparkConf sparkConf = new SparkConf().setAppName("JavaSparkPi");
JavaSparkContext jsc = new JavaSparkContext(sparkConf);
int slices = (args.length == 1) ? Integer.parseInt(args[0]) : 2;
int n = 100000 * slices;
List l = new ArrayList(n);
for (int i = 0; i < n; i++) {
l.add(i);
}
JavaRDD dataSet = jsc.parallelize(l, slices);
int count = dataSet.map(new Function() {
@Override
public Integer call(Integer integer) {
double x = Math.random() * 2 - 1;
double y = Math.random() * 2 - 1;
return (x * x + y * y < 1) ? 1 : 0;
}
}).reduce(new Function2() {
@Override
public Integer call(Integer integer, Integer integer2) {
return integer + integer2;
}
});
System.out.println("Pi is roughly " + 4.0 * count / n);
jsc.stop();
}
}
```
## Python
```
import argparse
import logging
from operator import add
from random import random
from pyspark.sql import SparkSession
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
def calculate_pi(partitions, output_uri):
"""
Calculates pi by testing a large number of random numbers against a unit circle
inscribed inside a square. The trials are partitioned so they can be run in
parallel on cluster instances.
:param partitions: The number of partitions to use for the calculation.
:param output_uri: The URI where the output is written, typically an Amazon S3
bucket, such as 's3://example-bucket/pi-calc'.
"""
def calculate_hit(_):
x = random() * 2 - 1
y = random() * 2 - 1
return 1 if x**2 + y**2 < 1 else 0
tries = 100000 * partitions
logger.info(
"Calculating pi with a total of %s tries in %s partitions.", tries, partitions
)
with SparkSession.builder.appName("My PyPi").getOrCreate() as spark:
hits = (
spark.sparkContext.parallelize(range(tries), partitions)
.map(calculate_hit)
.reduce(add)
)
pi = 4.0 * hits / tries
logger.info("%s tries and %s hits gives pi estimate of %s.", tries, hits, pi)
if output_uri is not None:
df = spark.createDataFrame([(tries, hits, pi)], ["tries", "hits", "pi"])
df.write.mode("overwrite").json(output_uri)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(
"--partitions",
default=2,
type=int,
help="The number of parallel partitions to use when calculating pi.",
)
parser.add_argument(
"--output_uri", help="The URI where output is saved, typically an S3 bucket."
)
args = parser.parse_args()
calculate_pi(args.partitions, args.output_uri)
```
# Verbessern der Spark Leistung mit Amazon S3
Amazon EMR bietet Features, mit denen die Leistung optimiert werden kann, wenn Spark für Abfragen und Lese- bzw. Schreiboperationen über Daten in Amazon S3 verwendet wird.
[S3 Select](https://aws.amazon.com/blogs/aws/s3-glacier-select/) kann in einigen Anwendungen die Abfrageleistung bei CSV- und JSON-Dateien verbessern, indem die Verarbeitung an Amazon S3 ausgelagert wird.
Der EMRFS S3-optimierte Committer ist eine Alternative zur [OutputCommitter](https://hadoop.apache.org/docs/current/api/org/apache/hadoop/mapreduce/OutputCommitter.html)Klasse, die die Funktion für mehrteilige Uploads von EMRFS verwendet, um die Leistung beim Schreiben von Parquet-Dateien auf Amazon S3 mithilfe von Spark, und Datasets zu verbessern. DataFrames
**Topics**
+ [S3 Select mit Spark zur Verbesserung der Leistung bei Abfragen verwenden](emr-spark-s3select.md)
+ [EMR Spark MagicCommitProtocol](emr-spark-magic-commit-protocol.md)
+ [EMRFS-S3-optimierte Committer verwenden](emr-spark-s3-optimized-committer.md)
+ [Verwenden Sie das EMRFS-S3-optimierte Commit-Protokoll](emr-spark-s3-optimized-commit-protocol.md)
+ [Amazon-S3-Anforderungen mit EMRFS wiederholen](emr-spark-emrfs-retry.md)
# S3 Select mit Spark zur Verbesserung der Leistung bei Abfragen verwenden
**Wichtig**
Amazon S3 Select ist für Neukunden nicht mehr verfügbar. Bestandskunden von Amazon S3 Select können das Feature weiterhin wie gewohnt nutzen. [Weitere Informationen](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/)
Mit Amazon-EMR-Version 5.17.0 und höher können Sie [S3 Select](https://aws.amazon.com/blogs/aws/s3-glacier-select/) mit Spark auf Amazon EMR verwenden. *S3 Select* ermöglicht es Anwendungen, nur eine Teilmenge von Daten aus einem Objekt abzurufen. Bei Amazon EMR wird die numerische Arbeit zur Filterung großer Datensätze von dem Cluster an Amazon S3 ausgelagert. Dies kann die Leistung in einigen Anwendungen verbessern und reduziert die Menge der zwischen Amazon EMR und Amazon S3 übertragenen Daten.
S3 Select unterstützt CSV und JSON-Dateien, das Datenformat wird unter Verwendung von `s3selectCSV` und `s3selectJSON` angegeben. Weitere Informationen und Beispiele finden Sie unter [S3 Select in Ihrem Code angeben](#emr-spark-s3select-specify).
## Ist S3 Select das Richtige für meine Anwendung?
Wir empfehlen, dass Sie Benchmark-Tests für Ihre Anwendungen im Vergleich mit und ohne S3 Select durchführen, um zu sehen, ob es für Ihre Anwendung geeignet sein könnte.
Verwenden Sie die folgenden Richtlinien, um zu bestimmen, ob Ihre Anwendung ein Kandidat für die Verwendung von S3 ist:
+ Ihre Abfrage filtert mehr als die Hälfte des ursprünglichen Datensatzes.
+ Ihre Netzwerkverbindung zwischen Amazon S3 und dem Amazon-EMR-Cluster hat eine gute Übertragungsgeschwindigkeit und verfügbare Bandbreite. Amazon S3 komprimiert keine HTTP-Antworten, sodass die Antwortgröße bei komprimierten Eingabedateien wahrscheinlich zunimmt.
## Überlegungen und Einschränkungen
+ Die Amazon-S3-serverseitige Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln (SSE-C) und die clientseitige Verschlüsselung werden nicht unterstützt.
+ Die Eigenschaft `AllowQuotedRecordDelimiters` wird nicht unterstützt. Wenn diese Eigenschaft angegeben ist, schlägt die Abfrage fehl.
+ Nur CSV- und JSON-Dateien im UTF-8-Format werden unterstützt. Mehrzeilige Zeilen werden nicht unterstützt. CSVs
+ Es werden nur unkomprimierte oder gzip-Dateien unterstützt.
+ Die Optionen für die Datenformate CSV und JSON in Spark (z. B. `nanValue`, `positiveInf`, `negativeInf`) sowie Optionen zum Umgang mit beschädigten Datensätzen (z. B. der failfast-Modus zur frühen Terminierung und der dropmalformed-Modus zum Überspringen von Datensätzen im falschen Format) werden nicht unterstützt.
+ Die Verwendung von Kommas als Tausender-Trennzeichen wird bei Dezimalzahlen nicht unterstützt. Beispielweise ist `10,000` ungültig, `10000` wird unterstützt.
+ Kommentarzeichen auf der letzten Zeile werden nicht unterstützt.
+ Leere Zeilen am Ende einer Datei werden nicht verarbeitet.
+ Die folgenden Filter werden nicht an Amazon S3 ausgelagert:
+ Aggregatfunktionen wie `COUNT()` und `SUM()`.
+ Filter, die ein Attribut über einen `CAST()`-Aufruf konvertieren. Beispiel, `CAST(stringColumn as INT) = 1`.
+ Filter mit einem Attribut, das ein Objekt ist oder einem zusammengesetzten Attribut. Beispiel, `intArray[1] = 1, objectColumn.objectNumber = 1`.
+ Filter, deren Wert ist nicht literal ist. Beispiel: `intColumn1 = intColumn2`
+ Es werden nur die [von S3 Select unterstützten Datentypen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-glacier-select-sql-reference-data-types.html) unterstützt, und es gelten die dokumentierten Einschränkungen.
## S3 Select in Ihrem Code angeben
Die folgenden Beispiele zeigen, wie S3 Select für CSV mit Scala, SQL, R und PySpark angegeben wird. Auf die gleiche Weise können Sie mit S3 Select JSON als Datenformat festlegen. Eine Liste der Optionen, der Standardwerte und der Einschränkungen finden Sie unter [Optionen](#emr-spark-s3select-specify-options).
------
#### [ PySpark ]
```
spark
.read
.format("s3selectCSV") // "s3selectJson" for Json
.schema(...) // optional, but recommended
.options(...) // optional
.load("s3://path/to/my/datafiles")
```
------
#### [ R ]
```
read.df("s3://path/to/my/datafiles", "s3selectCSV", schema, header = "true", delimiter = "\t")
```
------
#### [ Scala ]
```
spark
.read
.format("s3selectCSV") // "s3selectJson" for Json
.schema(...) // optional, but recommended
.options(...) // optional. Examples:
// .options(Map("quote" -> "\'", "header" -> "true")) or
// .option("quote", "\'").option("header", "true")
.load("s3://path/to/my/datafiles")
```
------
#### [ SQL ]
```
CREATE TEMPORARY VIEW MyView (number INT, name STRING) USING s3selectCSV OPTIONS (path "s3://path/to/my/datafiles", header "true", delimiter "\t")
```
------
### Optionen
Die folgenden Optionen sind verfügbar, wenn `s3selectCSV` und `s3selectJSON` verwendet wird. Wenn nichts angegeben wird, werden die Standardwerte verwendet.
#### Optionen für S3selectCSV
| Option | Standard | Usage |
| --- | --- | --- |
| `compression` | `"none"` | Gibt an, ob Komprimierung verwendet wird. `"gzip"` wird neben `"none"` als einzige Einstellung unterstützt. |
| `delimiter` | "," | Gibt den Feldbegrenzer an. |
| `quote` | `'\"'` | Gibt das Zeichen an, das als Anführungszeichen verwendet wird. Die Angabe einer leeren Zeichenfolge wird nicht unterstützt und führt zu einem XML-Fehler aufgrund fehlerhaftem Format. |
| `escape` | `'\\'` | Gibt das Zeichen an, das als Escape-Zeichen verwendet wird. |
| `header` | `"false"` | `"false"` gibt an, dass es keine Kopfzeile gibt. `"true"` gibt an, dass die erste Zeile die Kopfzeile ist. Es werden ausschließlich Kopfzeilen in der ersten Zeile unterstützt, und leere Zeilen vor der Kopfzeile werden nicht unterstützt. |
| Kommentar | `"#"` | Gibt das Zeichen an, das als Kommentarzeichen verwendet wird. Der Kommentarindikator kann nicht deaktiviert werden. Dies bedeutet, dass der Wert `\u0000` nicht unterstützt wird. |
| `nullValue` | "" | |
#### Optionen für S3selectJSON
| Option | Standard | Usage |
| --- | --- | --- |
| `compression` | `"none"` | Gibt an, ob Komprimierung verwendet wird. `"gzip"` wird neben `"none"` als einzige Einstellung unterstützt. |
| `multiline` | „false“ | `"false"` gibt an, dass die JSON-Daten in S3 Select im `LINES`-Format vorliegt. Dies bedeutet, dass jede Zeile in den Eingabedaten genau ein JSON-Objekt enthält. `"true"` gibt an, dass die JSON-Daten in S3 Select im `DOCUMENT`-Format vorliegen. Dies bedeutet, dass sich ein JSON-Objekt in den Eingabedaten über mehrere Zeilen erstrecken kann. |
# EMR Spark MagicCommitProtocol
Ab EMR 6.15.0 MagicCommitProtocol wird es zur Standardeinstellung FileCommitProtocol für Spark, wenn das S3A-Dateisystem verwendet wird.
## MagicCommitProtocol
Dies MagicCommitProtocol ist eine alternative Implementierung von, die für [FileCommitProtocol](https://dlcdn.apache.org/spark/docs/2.4.2/api/java/org/apache/spark/internal/io/FileCommitProtocol.html)das Schreiben von Dateien mit EMR Spark auf Amazon S3 optimiert ist, wenn das S3A-Dateisystem verwendet wird. Dieses Protokoll zielt darauf ab, die Anwendungsleistung zu verbessern, indem die Verwendung von Umbenennungsvorgängen in Amazon S3 während der Job- und Task-Commit-Phasen vermieden wird.
Dies MagicCommitProtocol ist die FileCommitProtocol Standardimplementierung, die von Spark auf Amazon Elastic Map Reduce (EMR) verwendet wird, wenn das S3A-Dateisystem verwendet wird. Der verwendet MagicCommitProtocol intern den [MagicV2Committer, um die Dateischreibvorgänge](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/s3a-magicv2-committer.html) auf Amazon S3 durchzuführen.
Bei statischen Einfügevorgängen MagicCommitProtocol schreibt der die Dateien während der Commit-Phase der Aufgabe in den Ausgabespeicherort des Jobs. Im Gegensatz dazu erscheinen bei dynamischen Einfüge-Überschreibvorgängen die Dateien, die bei Versuchen mit der Aufgabe geschrieben wurden, erst nach dem Commit des Jobs am Ausgabespeicherort des Jobs. Dies wird erreicht, indem die Commit-Metadaten beim Commit-Aufruf der Aufgabe zurück in den Spark-Treiber exportiert werden.
## Aktivieren MagicCommitProtocol
Das MagicCommitProtocol ist standardmäßig aktiviert, wenn Spark auf Amazon Elastic Map Reduce (EMR) läuft, wenn das S3A-Dateisystem verwendet wird.
Um das S3A-Dateisystem zu verwenden, können Sie entweder:
1. Verwenden Sie das Dateischema wie `s3a://` bei der Definition der Tabelle, Partition oder des Verzeichnisses.
1. Stellen Sie die Konfiguration `fs.s3.impl=org.apache.hadoop.fs.s3a.S3AFileSystem` in core-site.xml ein.
## Deaktivierung der MagicCommitProtocol
1. Sie können `spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol` den Wert auf false setzen`SparkConf`, indem Sie ihn in a fest codieren `spark-submit` und ihn als `--conf` Parameter in der Spark-Shell oder in `spark-sql` Tools oder in übergeben. `conf/spark-defaults.conf` Weitere Informationen finden Sie unter [Spark-Konfiguration](https://spark.apache.org/docs/latest/configuration.html) in der Apache Spark-Dokumentation.
Das folgende Beispiel zeigt, wie ein `spark-sql` Befehl deaktiviert wird MagicCommitProtocol , während er ausgeführt wird.
```
spark-sql \
--conf spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol=false \
-e "INSERT OVERWRITE TABLE target_table SELECT * FROM source_table;"
```
1. Verwenden Sie die `spark-defaults` Konfigurationsklassifizierung, um die `spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol` Eigenschaft auf False zu setzen. Weitere Informationen finden Sie unter [Konfigurieren von Anwendungen](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html).
## MagicCommitProtocol Überlegungen
+ Beim Einfügen statischer Partitionen MagicCommitProtocol beansprucht der auf Spark-Executoren eine geringe Menge an Speicher für jede Datei, die durch einen Task-Versuch geschrieben wurde, bis die Aufgabe festgeschrieben oder abgebrochen wird. Bei den meisten Aufträgen ist die Menge des belegten Speichers vernachlässigbar. Für den Spark-Treiber ist kein zusätzlicher Speicherbedarf erforderlich
+ Beim dynamischen Einfügen von Partitionen MagicCommitProtocol benötigt der auf Spark-Treibern Speicherplatz, um die Metadateninformationen jeder übergebenen Datei zu speichern, bis der Job festgeschrieben oder abgebrochen wird. Bei den meisten Aufträgen ist die standardmäßige Speichereinstellung des Spark-Treibers vernachlässigbar.
Bei Aufträgen mit Aufgaben mit langer Laufzeit, die eine große Anzahl von Dateien schreiben, kann der Speicherverbrauch des Commit-Protokolls spürbar sein und Anpassungen des für Spark zugewiesenen Speichers erfordern, insbesondere für Spark-Ausführer. Sie können den Speicher mithilfe der `spark.driver.memory`-Eigenschaft für Spark-Treiber und der Eigenschaft für `spark.executor.memory`-Spark-Aufträge optimieren. Als Richtlinie gilt, dass für eine einzelne Aufgabe, die 100.000 Dateien schreibt, in der Regel zusätzliche 200 MB Arbeitsspeicher benötigt werden. Weiter Informationen finden Sie unter [Anwendungseigenschaften](https://spark.apache.org/docs/latest/configuration.html#application-properties) in der Dokumentation zur Konfiguration von Apache Spark.
# EMRFS-S3-optimierte Committer verwenden
Der EMRFS S3-optimierte Committer ist eine alternative [OutputCommitter](https://hadoop.apache.org/docs/current/api/org/apache/hadoop/mapreduce/OutputCommitter.html)Implementierung, die für das Schreiben von Dateien in Amazon S3 bei Verwendung von EMRFS optimiert ist. Der für EMRFS S3 optimierte Comitter verbessert die Anwendungsleistung durch Umgehung der Operationen zum Auflisten und Umbenennen, die während der Commit-Phasen von Aufträgen und Aufgaben in Amazon S3 durchgeführt werden. Die Committer-Klasse ist verfügbar für Amazon-EMR-Version 5.19.0 und höher und ist bei Amazon EMR 5.20.0 und höher standardmäßig aktiviert. Der Committer wird für Spark-Jobs verwendet, die Spark oder Datasets verwenden. DataFrames Ab Amazon EMR 6.4.0 kann dieser Committer für alle gängigen Formate verwendet werden, einschließlich Parquet, ORC und textbasierte Formate (einschließlich CSV und JSON). Für Versionen vor Amazon EMR 6.4.0 wird nur das Parquet-Format unterstützt. Es gibt Situationen, in denen der Committer nicht verwendet wird. Weitere Informationen finden Sie unter [Anforderungen für den S3-optimierten EMRFS-Committer](emr-spark-committer-reqs.md).
**Topics**
+ [Anforderungen für den S3-optimierten EMRFS-Committer](emr-spark-committer-reqs.md)
+ [Der S3-optimierte EMRFS-Committer und mehrteilige Uploads](emr-spark-committer-multipart.md)
+ [Überlegungen zur Auftragsoptimierung](emr-spark-committer-tuning.md)
+ [Aktivieren Sie den S3-optimierten Committer für Amazon EMR 5.19.0](emr-spark-committer-enable.md)
# Anforderungen für den S3-optimierten EMRFS-Committer
Der S3-optimierte EMRFS-Committer wird verwendet, wenn die folgenden Bedingungen erfüllt sind:
+ Sie führen Spark-Jobs aus, die Spark oder Datasets verwenden DataFrames, um Dateien in Amazon S3 zu schreiben. Ab Amazon EMR 6.4.0 kann dieser Committer für alle gängigen Formate verwendet werden, einschließlich Parquet, ORC und textbasierte Formate (einschließlich CSV und JSON). Für Versionen vor Amazon EMR 6.4.0 wird nur das Parquet-Format unterstützt.
+ In Amazon EMR sind mehrteilige Uploads aktiviert. Das ist die Standardeinstellung. Weitere Informationen finden Sie unter [Der S3-optimierte EMRFS-Committer und mehrteilige Uploads](emr-spark-committer-multipart.md).
+ Die integrierte Dateiformatunterstützung von Spark wird verwendet. Die integrierte Dateiformatunterstützung wird unter folgenden Umständen verwendet:
+ Bei Hive-Metastore-Tabellen, wenn `spark.sql.hive.convertMetastoreParquet` für Parquet-Tabellen auf `true` oder `spark.sql.hive.convertMetastoreOrc` für Orc-Tabellen mit Amazon EMR 6.4.0 oder höher auf `true` eingestellt. Dies sind die Standardeinstellungen.
+ Wenn Aufträge in Datenquellen oder Tabellen im Dateiformat schreiben, wird beispielsweise die Zieltabelle mit der `USING parquet` Klausel erstellt.
+ Wenn Aufträge in nicht partitionierte Hive-Metastore-Parquet-Tabellen schreiben. Eine bekannte Einschränkung besteht darin, dass die in Spark integrierte Parquet-Unterstützung keine partitionierten Hive-Tabellen unterstützt. Weitere Informationen finden Sie unter [Hive Metastore Parquet-Tabellenkonvertierung](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#hive-metastore-parquet-table-conversion) im Apache Spark DataFrames and Datasets Guide.
+ Spark-Job-Operationen, die beispielsweise `${table_location}/k1=v1/k2=v2/` in einen Standardspeicherort für Partitionen schreiben, verwenden den Committer. Der Committer wird nicht verwendet, wenn ein Job-Vorgang in einen benutzerdefinierten Partitionsspeicherort schreibt, z. B. wenn mit dem `ALTER TABLE SQL`-Befehl ein benutzerdefinierter Partitionsspeicherort festgelegt wurde.
+ Für Spark müssen die folgenden Werte verwendet werden:
+ Der Eigenschaft `spark.sql.parquet.fs.optimized.committer.optimization-enabled` muss auf `true` eingestellt sein. Dies ist die Standardeinstellung bei Amazon EMR 5.20.0 und höher. Bei Amazon EMR 5.19.0 lautet der Standardwert `false`. Weitere Informationen zum Konfigurieren dieses Werts finden Sie unter [Aktivieren Sie den S3-optimierten Committer für Amazon EMR 5.19.0](emr-spark-committer-enable.md).
+ Beim Schreiben in nicht partitionierte Hive-Metastore-Tabellen werden nur die Dateiformate Parquet und Orc unterstützt. `spark.sql.hive.convertMetastoreParquet`muss auf gesetzt sein, `true` wenn in nicht partitionierte Parquet Hive-Metastore-Tabellen geschrieben werden. `spark.sql.hive.convertMetastoreOrc`muss auf gesetzt sein, `true` wenn in nicht partitionierte Orc Hive Metastore-Tabellen geschrieben werden. Dies sind die Standardeinstellungen.
+ muss `spark.sql.parquet.output.committer.class` auf `com.amazon.emr.committer.EmrOptimizedSparkSqlParquetOutputCommitter` festgelegt sein. Dies ist die Standardeinstellung.
+ `spark.sql.sources.commitProtocolClass` muss auf `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol` oder `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol` eingestellt sein. `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol` ist die Standardeinstellung für die Amazon-EMR-5.x-Serie, Version 5.30.0 und höher, und für die Amazon-EMR-6.x-Serie, Version 6.2.0 und höher. `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol` ist die Standardeinstellung für frühere Amazon-EMR-Versionen.
+ Wenn Spark-Aufträge partitionierte Parquet-Datasets durch dynamische Partitionsspalten überschreiben, dann müssen die Schreiboption `partitionOverwriteMode` und `spark.sql.sources.partitionOverwriteMode` auf `static` eingestellt sein. Dies ist die Standardeinstellung.
**Anmerkung**
Die Schreiboption `partitionOverwriteMode` wurde mit Spark 2.4.0 eingeführt. Legen Sie für Spark-Version 2.3.2, die in Amazon-EMR-Version 5.19.0 enthalten ist, die Eigenschaft `spark.sql.sources.partitionOverwriteMode` fest.
## Fälle, in denen der S3-optimierte EMRFS-Committer nicht verwendet wird
Im Allgemeinen wird der S3-optimierte Committer in den folgenden Situationen nicht verwendet.
****
| Situation | Warum der Committer nicht verwendet wird |
| --- | --- |
| Wenn Sie in HDFS schreiben | Der Committer unterstützt nur das Schreiben in Amazon S3 mit EMRFS. |
| Bei Verwendung des S3A-Dateisystems | Der Committer unterstützt nur EMRFS. |
| Wenn Sie die RDD-API von Spark verwenden MapReduce | Der Committer unterstützt nur die Verwendung von SparkSQL oder Dataset DataFrame. APIs |
Die folgenden Scala-Beispiele veranschaulichen einige zusätzliche Situationen, die verhindern, dass der EMRFS-S3-optimierte Committer vollständig (erstes Beispiel) oder teilweise (zweites Beispiel) verwendet werden kann.
**Example – Dynamischer Partitionsüberschreibmodus**
Das folgende Scala-Beispiel weist Spark an, einen anderen Commit-Algorithmus zu verwenden, wodurch die Verwendung des für EMRFS S3 optimierten Committers insgesamt verhindert wird. Der Code legt die Eigenschaft `partitionOverwriteMode` auf `dynamic` fest, sodass nur die Partitionen überschrieben werden, auf die Sie Daten schreiben. Anschließend werden dynamische Partitionsspalten durch `partitionBy` angegeben und der Schreibmodus ist auf `overwrite` eingestellt.
```
val dataset = spark.range(0, 10)
.withColumn("dt", expr("date_sub(current_date(), id)"))
dataset.write.mode("overwrite")
.option("partitionOverwriteMode", "dynamic")
.partitionBy("dt")
.parquet("s3://amzn-s3-demo-bucket1/output")
```
Sie müssen alle drei Einstellungen konfigurieren, um die Verwendung des S3-optimierten Committers zu vermeiden. Wenn Sie dies tun, führt Spark einen anderen Commit-Algorithmus aus, der im Commit-Protokoll von Spark angegeben ist. Für Amazon-EMR-5.x-Versionen vor 5.30.0 und für Amazon-EMR-6.x-Versionen vor 6.2.0 verwendet das Commit-Protokoll das Staging-Verzeichnis von Spark, ein temporäres Verzeichnis, das unter dem Ausgabespeicherort erstellt wird, der mit `.spark-staging` beginnt. Der Algorithmus benennt Partitionsverzeichnisse nacheinander um, was sich negativ auf die Leistung auswirken kann. Weitere Informationen zu den Amazon-EMR-Versionen 5.30.0 und höher sowie 6.2.0 und höher finden Sie unter [Verwenden Sie das EMRFS-S3-optimierte Commit-Protokoll](emr-spark-s3-optimized-commit-protocol.md).
Der Algorithmus in Spark 2.4.0 folgt diesen Schritten:
1. Aufgabenversuche schreiben ihre Ausgabe in Partitionsverzeichnisse unterhalb des Staging-Verzeichnisses von Spark, beispielsweise `${outputLocation}/spark-staging-${jobID}/k1=v1/k2=v2/`.
1. Für jede geschriebene Partition verfolgt der Aufgabenversuch die relativen Partitionspfade, z. B. `k1=v1/k2=v2`.
1. Wenn eine Aufgabe erfolgreich abgeschlossen wurde, stellt sie dem Treiber alle zugehörigen Partitionspfade bereit, die von ihr nachverfolgt wurden.
1. Nachdem alle Aufgaben abgeschlossen wurden, sammelt die Auftrags-Commit-Phase alle die Partitionsverzeichnisse, die von erfolgreichen Aufgabenversuchen unter dem Staging-Verzeichnis von Spark geschrieben wurden. Spark benennt jedes dieser Verzeichnisse mithilfe von Verzeichnisstruktur-Umbenennungsoperationen sequenziell bis zu ihrem endgültigen Ausgabespeicherort um.
1. Das Staging-Verzeichnis wird gelöscht, bevor der Auftrags-Commit-Phase abgeschlossen ist.
**Example – Benutzerdefinierter Partitionsspeicherort**
In diesem Beispiel wird der Scala-Code in zwei Partitionen eingefügt. Eine Partition verfügt über einen benutzerdefinierten Partitionsspeicherort. Die andere Partition verwendet den Standard-Partitionsspeicherort. Der S3-optimierte EMRFS-Committer wird nur zum Schreiben der Aufgabenausgabe in die Partition genutzt, die den Standard-Partitionsspeicherort verwendet.
```
val table = "dataset"
val location = "s3://bucket/table"
spark.sql(s"""
CREATE TABLE $table (id bigint, dt date)
USING PARQUET PARTITIONED BY (dt)
LOCATION '$location'
""")
// Add a partition using a custom location
val customPartitionLocation = "s3://bucket/custom"
spark.sql(s"""
ALTER TABLE $table ADD PARTITION (dt='2019-01-28')
LOCATION '$customPartitionLocation'
""")
// Add another partition using default location
spark.sql(s"ALTER TABLE $table ADD PARTITION (dt='2019-01-29')")
def asDate(text: String) = lit(text).cast("date")
spark.range(0, 10)
.withColumn("dt",
when($"id" > 4, asDate("2019-01-28")).otherwise(asDate("2019-01-29")))
.write.insertInto(table)
```
Der Scala-Code erstellt die folgenden Amazon-S3-Objekte:
```
custom/part-00001-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
custom_$folder$
table/_SUCCESS
table/dt=2019-01-29/part-00000-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
table/dt=2019-01-29_$folder$
table_$folder$
```
Beim Schreiben in Partitionen an benutzerdefinierten Speicherorten verwendet Spark einen Commit-Algorithmus, ähnlich wie im vorherigen Beispiel. Dies wird im Folgenden beschrieben. Genau wie bei dem vorherigen Beispiel führt der Algorithmus zu sequenziellen Umbenennungen, wodurch die Leistung beeinträchtigt werden kann.
1. Beim Schreiben von Ausgabe in eine Partition an einem benutzerdefinierten Speicherort werden Aufgaben in eine Datei unter dem Staging-Verzeichnis von Spark geschrieben, das unter dem endgültigen Ausgabespeicherort erstellt wird. Der Name der Datei enthält eine zufällige UUID zum Schutz vor Datei-Kollisionen. Der Aufgabe-Versuch verfolgt jede Datei zusammen mit dem gewünschten endgültigen Ausgabepfad nach.
1. Wenn eine Aufgabe erfolgreich abgeschlossen wird, stellt sie dem Treiber die Dateien und die für sie gewünschten endgültigen Ausgabepfade bereit.
1. Nachdem alle Aufgaben beendet wurden, benennt die Auftrags-Commit-Phase alle Dateien, die für Partitionen an benutzerdefinierten Speicherorten geschrieben wurden, sequentiell in ihre endgültigen Ausgabepfade um.
1. Das Staging-Verzeichnis wird gelöscht, bevor der Auftrags-Commit-Phase abgeschlossen ist.
# Der S3-optimierte EMRFS-Committer und mehrteilige Uploads
Um den S3-optimierten EMRFS-Committer zu verwenden, müssen Sie mehrteilige Uploads in Amazon EMR aktivieren. Mehrteilige Uploads sind standardmäßig aktiviert. Sie können diese Option bei Bedarf erneut aktivieren. Weitere Informationen finden Sie unter [Konfigurieren von mehrteiligen Uploads für Amazon S3](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart) im *Verwaltungshandbuch für Amazon EMR*.
Der S3-optimierte EMRFS-Committer verwendet die transaktionsähnlichen Merkmale von mehrteiligen Uploads, um sicherzustellen, dass Dateien, die beim Versuch, Aufgaben auszuführen geschrieben werden, nur am Ausgabespeicherort des Auftrags angezeigt werden. Durch die Verwendung von mehrteiligen Uploads auf diese Weise verbessert der Committer die Leistung des Task-Commits im Vergleich zur Standardalgorithmusversion 2. FileOutputCommitter Wenn Sie den S3-optimierten EMRFS-Committer verwenden, gilt es einige wichtige Unterschiede zu dem herkömmlichen Verhalten bei mehrteiligen Uploads zu berücksichtigen:
+ Mehrteilige Uploads werden immer ausgeführt, unabhängig von der Dateigröße. Dies unterscheidet sich vom Standardverhalten von EMRFS, bei dem die Eigenschaft `fs.s3n.multipart.uploads.split.size` die Dateigröße steuert, in der mehrteilige Uploads ausgelöst werden.
+ Mehrteilige Uploads verbleiben für einen längeren Zeitraum in einem Status, in dem sie nicht abgeschlossen sind, bis die Aufgabe übertragen oder abgebrochen wird. Dies unterscheidet sich von der Standard-Verhalten von EMRFS. Dort wird ein mehrteiliger Upload abgeschlossen, wenn eine Aufgabe den Schreibvorgang für eine bestimmte Datei beendet hat.
Aufgrund dieser Unterschiede vergrößert sich bei mehrteiligen Uploads die Wahrscheinlichkeit, dass unvollständige mehrteilige Uploads zurückbleiben, wenn ein Spark Executor JVM abstürzt oder zerstört wird, während Aufgaben ausgeführt oder Daten auf Amazon S3 geschrieben werden. Aus diesem Grund sollten Sie bei Verwendung des S3-optimierten EMRFS-Committer darauf achten, den bewährten Methoden für die Verwaltung von fehlgeschlagenen mehrteiligen Uploads zu folgen. Weitere Informationen finden Sie unter [Bewährte Methoden](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#emr-bucket-bestpractices) für die Arbeit mit Amazon-S3-Buckets im *Verwaltungshandbuch für Amazon EMR*.
# Überlegungen zur Auftragsoptimierung
Der S3-optimierte EMRFS-Committer verbraucht eine geringe Speichermenge für jede Datei, die versuchsweise von einer Aufgabe geschrieben wird, bis die Aufgabe übermittelt oder abgebrochen wird. Bei den meisten Aufträgen ist die Menge des belegten Speichers vernachlässigbar. Bei Aufträgen mit Aufgaben mit langer Ausführungsdauer, die eine große Anzahl von Dateien schreiben, macht sich der Arbeitsspeicher, den der Committer benötigt, bemerkbar, und dies erfordert möglicherweise Anpassungen an den für Spark Executor zugeteilten Arbeitsspeicher. Sie können die Eigenschaft `spark.executor.memory` verwenden, um den Executor-Arbeitsspeicher anzupassen. Als Faustregel gilt: für jeweils 100.000 Dateien, die eine einzelne Aufgabe schreib, werden in der Regel zusätzlich 100 MB Arbeitsspeicher benötigt. Weiter Informationen finden Sie unter [Anwendungseigenschaften](https://spark.apache.org/docs/latest/configuration.html#application-properties) in der Dokumentation zur Konfiguration von Apache Spark.
# Aktivieren Sie den S3-optimierten Committer für Amazon EMR 5.19.0
Wenn Sie Amazon EMR 5.19.0 verwenden, können Sie die Eigenschaft `spark.sql.parquet.fs.optimized.committer.optimization-enabled` manuell auf `true` einstellen, wenn Sie einen Cluster erstellen, oder aus Spark heraus, wenn Sie Amazon EMR verwenden.
## Aktivieren des S3-optimierten EMRFS-Committers beim Erstellen eines Clusters
Verwenden Sie die Konfigurationsklassifizierung `spark-defaults`, um die `spark.sql.parquet.fs.optimized.committer.optimization-enabled`-Eigenschaften auf `true` festzulegen. Weitere Informationen finden Sie unter [Anwendungen konfigurieren](emr-configure-apps.md).
## Aktivieren des S3-optimierten EMRFS-Committers über Spark
Sie können `spark.sql.parquet.fs.optimized.committer.optimization-enabled` auf `true` festlegen, indem Sie dies in einer `SparkConf` fest kodieren, als `--conf`-Parameter in der Spark-Shell übergeben, die Tools `spark-submit` bzw. `spark-sql` verwenden oder dies in `conf/spark-defaults.conf` angeben. Weiter Informationen finden Sie unter [Spark-Konfiguration](https://spark.apache.org/docs/latest/configuration.html) in der Apache-Spark-Dokumentation.
Im folgenden Beispiel wird gezeigt, wie Sie den Committer während der Ausführung eines spark-sql-Befehls aktivieren.
```
spark-sql \
--conf spark.sql.parquet.fs.optimized.committer.optimization-enabled=true \
-e "INSERT OVERWRITE TABLE target_table SELECT * FROM source_table;"
```
# Verwenden Sie das EMRFS-S3-optimierte Commit-Protokoll
Das EMRFS S3-optimierte Commit-Protokoll ist eine alternative [FileCommitProtocol](https://spark.apache.org/docs/2.2.0//api/java/org/apache/spark/internal/io/FileCommitProtocol.html)Implementierung, die für das Schreiben von Dateien mit dynamischem Spark-Partitionsüberschreiben in Amazon S3 optimiert ist, wenn EMRFS verwendet wird. Das Protokoll verbessert die Anwendungsleistung, indem Umbenennungsvorgänge in Amazon S3 während der Commit-Phase für das dynamische Überschreiben von Spark-Partitionen vermieden werden.
Beachten Sie, dass der für [EMRFS S3 optimierte Committer auch die Leistung verbessert, da Umbenennungsvorgänge vermieden](emr-spark-s3-optimized-committer.html) werden. Es funktioniert jedoch nicht für Fälle dynamischer Partitionsüberschreibungen, während die Verbesserungen des Commit-Protokolls nur auf Fälle dynamischer Partitionsüberschreibungen abzielen.
Die Committer-Klasse ist verfügbar für Amazon-EMR-Version 5.30.0 und höher und ist bei 6.2.0 und höher standardmäßig aktiviert. Amazon EMR hat ab Version 5.31.0 eine Verbesserung der Parallelität hinzugefügt. Das Protokoll wird für Spark-Jobs verwendet, die Spark oder Datasets verwenden. DataFrames Es gibt Situationen, in denen das Commit Protokoll nicht verwendet wird. Weitere Informationen finden Sie unter [Anforderungen für das EMRFS-S3-optimierte Commit-Protokoll](emr-spark-committer-reqs.md).
**Topics**
+ [Anforderungen für das EMRFS-S3-optimierte Commit-Protokoll](emr-spark-commit-protocol-reqs.md)
+ [Das S3-optimierte EMRFS-Commit-Protokoll und mehrteilige Uploads](emr-spark-commit-protocol-multipart.md)
+ [Überlegungen zur Auftragsoptimierung](emr-spark-commit-protocol-tuning.md)
# Anforderungen für das EMRFS-S3-optimierte Commit-Protokoll
Das EMRFS-S3-optimierte Commit-Protokoll wird verwendet, wenn die folgenden Bedingungen erfüllt sind:
+ Sie führen Spark-Jobs aus, die Spark oder Datasets verwenden DataFrames, um partitionierte Tabellen zu überschreiben.
+ Sie führen Spark-Jobs aus, deren Partitionsüberschreibmodus `dynamic` ist.
+ In Amazon EMR sind mehrteilige Uploads aktiviert. Das ist die Standardeinstellung. Weitere Informationen finden Sie unter [Das S3-optimierte EMRFS-Commit-Protokoll und mehrteilige Uploads](emr-spark-commit-protocol-multipart.md).
+ Der Dateisystem-Cache für EMRFS ist aktiviert. Das ist die Standardeinstellung. Vergewissern Sie sich, dass die Einstellung `fs.s3.impl.disable.cache` auf `false` gesetzt ist.
+ Die integrierte Datenquellenunterstützung von Spark wird verwendet. Die integrierte Datenquellenunterstützung wird in den folgenden Fällen verwendet:
+ Wenn Aufträge in integrierte Datenquellen oder Tabellen schreiben.
+ Wenn Aufträge in die Parquet-Tabelle des Hive-Metastores schreiben. Das passiert, wenn `spark.sql.hive.convertInsertingPartitionedTable` und `spark.sql.hive.convertMetastoreParquet` beide auf „wahr“ gesetzt sind. Dies sind die Standardeinstellungen.
+ Wenn Aufträge in die ORC-Tabelle des Hive-Metastores schreiben. Das passiert, wenn `spark.sql.hive.convertInsertingPartitionedTable` und `spark.sql.hive.convertMetastoreOrc` beide auf `true` gesetzt sind. Dies sind die Standardeinstellungen.
+ Spark-Auftrags-Vorgänge, die z. B. in einen Standard-Partitionsspeicherort schreiben, z. B. `${table_location}/k1=v1/k2=v2/`, verwenden das Commit-Protokoll. Das Protokoll wird nicht verwendet, wenn ein Jobvorgang in einen benutzerdefinierten Partitionsspeicherort schreibt, beispielsweise wenn ein benutzerdefinierter Partitionsspeicherort mit dem Befehl `ALTER TABLE SQL` festgelegt wird.
+ Für Spark müssen die folgenden Werte verwendet werden:
+ muss `spark.sql.sources.commitProtocolClass` auf `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol` festgelegt sein. Dies ist die Standardeinstellung für Amazon-EMR-Versionen 5.30.0 und höher sowie 6.2.0 und höher.
+ Die Schreiboption `partitionOverwriteMode` oder `spark.sql.sources.partitionOverwriteMode` muss auf `dynamic` gesetzt sein. Die Standardeinstellung lautet `static`.
**Anmerkung**
Die Schreiboption `partitionOverwriteMode` wurde mit Spark 2.4.0 eingeführt. Legen Sie für Spark-Version 2.3.2, die in Amazon-EMR-Version 5.19.0 enthalten ist, die Eigenschaft `spark.sql.sources.partitionOverwriteMode` fest.
+ Wenn Spark-Aufträge in die Hive-Metastore-Parquet-Tabelle überschreiben muss `spark.sql.hive.convertMetastoreParquet`, `spark.sql.hive.convertInsertingPartitionedTable` und `spark.sql.hive.convertMetastore.partitionOverwriteMode` auf `true` gesetzt werden. Dies sind die Standardeinstellungen.
+ Wenn Spark-Aufträge in die Hive-Metastore-ORC-Tabelle überschreiben muss `spark.sql.hive.convertMetastoreOrc`, `spark.sql.hive.convertInsertingPartitionedTable` und `spark.sql.hive.convertMetastore.partitionOverwriteMode` auf `true` gesetzt werden. Dies sind die Standardeinstellungen.
**Example – Dynamischer Partitionsüberschreibmodus**
In diesem Scala-Beispiel wird die Optimierung ausgelöst. Als erstes setzen Sie die `partitionOverwriteMode`-Eigenschaft auf `dynamic`. Dadurch werden nur die Partitionen überschrieben, auf die Sie Daten schreiben. Anschließend geben Sie dynamische Partitionsspalten mit `partitionBy` an und legen den Schreibmodus auf `overwrite` fest.
```
val dataset = spark.range(0, 10)
.withColumn("dt", expr("date_sub(current_date(), id)"))
dataset.write.mode("overwrite") // "overwrite" instead of "insert"
.option("partitionOverwriteMode", "dynamic") // "dynamic" instead of "static"
.partitionBy("dt") // partitioned data instead of unpartitioned data
.parquet("s3://amzn-s3-demo-bucket1/output") // "s3://" to use Amazon EMR file system, instead of "s3a://" or "hdfs://"
```
## Wenn das EMRFS-S3-optimierte Commit-Protokoll nicht verwendet wird
Im Allgemeinen funktioniert das für EMRFS S3 optimierte Commit-Protokoll genauso wie das Open-Source-Standard-Spark-Commit-Protokoll. `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol` In den folgenden Situationen wird keine Optimierung durchgeführt.
****
| Situation | Warum das Commit-Protokoll nicht verwendet wird |
| --- | --- |
| Wenn Sie in HDFS schreiben | Das Commit-Protokoll unterstützt nur das Schreiben in Amazon S3 mit EMRFS-Technologie. |
| Bei Verwendung des S3A-Dateisystems | Das Commit-Protokoll unterstützt nur EMRFS. |
| Wenn Sie die RDD-API von MapReduce Spark verwenden | Das Commit-Protokoll unterstützt nur die Verwendung von SparkSQL oder DataFrame Dataset. APIs |
| Wenn das dynamische Überschreiben der Partition nicht ausgelöst wird | Das Commit-Protokoll optimiert nur Fälle, in denen dynamische Partitionen überschrieben werden. Für andere Fälle siehe [EMRFS-S3-optimierte Committer verwenden](emr-spark-s3-optimized-committer.md). |
Die folgenden Scala-Beispiele veranschaulichen einige zusätzliche Situationen, die das EMRFS-S3-optimierte Commit-Protokoll an `SQLHadoopMapReduceCommitProtocol` delegiert.
**Example – Dynamischer Partitionsüberschreibmodus mit benutzerdefiniertem Partitionsspeicherort**
In diesem Beispiel überschreiben die Scala-Programme zwei Partitionen im dynamischen Partitionsüberschreibmodus. Eine Partition verfügt über einen benutzerdefinierten Partitionsspeicherort. Die andere Partition verwendet den Standard-Partitionsspeicherort. Das S3-optimierte EMRFS-Commit-Protokoll wird nur zum Verbessern der Aufgabenausgabe in die Partition genutzt, die den Standard-Partitionsspeicherort verwendet.
```
val table = "dataset"
val inputView = "tempView"
val location = "s3://bucket/table"
spark.sql(s"""
CREATE TABLE $table (id bigint, dt date)
USING PARQUET PARTITIONED BY (dt)
LOCATION '$location'
""")
// Add a partition using a custom location
val customPartitionLocation = "s3://bucket/custom"
spark.sql(s"""
ALTER TABLE $table ADD PARTITION (dt='2019-01-28')
LOCATION '$customPartitionLocation'
""")
// Add another partition using default location
spark.sql(s"ALTER TABLE $table ADD PARTITION (dt='2019-01-29')")
def asDate(text: String) = lit(text).cast("date")
spark.range(0, 10)
.withColumn("dt",
when($"id" > 4, asDate("2019-01-28")).otherwise(asDate("2019-01-29")))
.createTempView(inputView)
// Set partition overwrite mode to 'dynamic'
spark.sql(s"SET spark.sql.sources.partitionOverwriteMode=dynamic")
spark.sql(s"INSERT OVERWRITE TABLE $table SELECT * FROM $inputView")
```
Der Scala-Code erstellt die folgenden Amazon-S3-Objekte:
```
custom/part-00001-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
custom_$folder$
table/_SUCCESS
table/dt=2019-01-29/part-00000-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
table/dt=2019-01-29_$folder$
table_$folder$
```
Das Schreiben in benutzerdefinierte Partitionsspeicherorte in früheren Spark-Versionen kann zu Datenverlust führen. In diesem Beispiel `dt='2019-01-28'` würde die Partition verloren gehen. Weitere Informationen finden Sie unter [SPARK-35106](https://issues.apache.org/jira/browse/SPARK-35106). Dieses Problem wurde in Amazon-EMR-Version 5.33.0 und höher behoben, ausgenommen 6.0.x und 6.1.x.
Beim Schreiben in Partitionen an benutzerdefinierten Speicherorten verwendet Spark einen Commit-Algorithmus, ähnlich wie im vorherigen Beispiel. Dies wird im Folgenden beschrieben. Genau wie bei dem vorherigen Beispiel führt der Algorithmus zu sequenziellen Umbenennungen, wodurch die Leistung beeinträchtigt werden kann.
Der Algorithmus in Spark 2.4.0 folgt diesen Schritten:
1. Beim Schreiben von Ausgabe in eine Partition an einem benutzerdefinierten Speicherort werden Aufgaben in eine Datei unter dem Staging-Verzeichnis von Spark geschrieben, das unter dem endgültigen Ausgabespeicherort erstellt wird. Der Name der Datei enthält eine zufällige UUID zum Schutz vor Datei-Kollisionen. Der Aufgabe-Versuch verfolgt jede Datei zusammen mit dem gewünschten endgültigen Ausgabepfad nach.
1. Wenn eine Aufgabe erfolgreich abgeschlossen wird, stellt sie dem Treiber die Dateien und die für sie gewünschten endgültigen Ausgabepfade bereit.
1. Nachdem alle Aufgaben beendet wurden, benennt die Auftrags-Commit-Phase alle Dateien, die für Partitionen an benutzerdefinierten Speicherorten geschrieben wurden, sequentiell in ihre endgültigen Ausgabepfade um.
1. Das Staging-Verzeichnis wird gelöscht, bevor der Auftrags-Commit-Phase abgeschlossen ist.
# Das S3-optimierte EMRFS-Commit-Protokoll und mehrteilige Uploads
Um die Optimierung für dynamisches Partitionsüberschreiben im EMRFS-S3-optimierten Commit-Protokoll nutzen zu können, müssen mehrteilige Uploads in Amazon EMR aktiviert sein. Mehrteilige Uploads sind standardmäßig aktiviert. Sie können diese Option bei Bedarf erneut aktivieren. Weitere Informationen finden Sie unter [Konfigurieren von mehrteiligen Uploads für Amazon S3](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart) im *Verwaltungshandbuch für Amazon EMR*.
Beim dynamischen Überschreiben der Partition nutzt das für EMRFS S3 optimierte Commit-Protokoll die transaktionsähnlichen Eigenschaften mehrteiliger Uploads, um sicherzustellen, dass Dateien, die durch Aufgabenversuche geschrieben wurden, beim Auftrags-Commit nur am Ausgabeort des Auftrags angezeigt werden. Durch die Verwendung von mehrteiligen Uploads auf diese Weise verbessert das Commit-Protokoll die Leistung von Auftrags-Commits im Vergleich zum Standard-`SQLHadoopMapReduceCommitProtocol`. Wenn Sie das S3-optimierte EMRFS-Commit-Protokoll verwenden, gilt es einige wichtige Unterschiede zu dem herkömmlichen Verhalten bei mehrteiligen Uploads zu berücksichtigen:
+ Mehrteilige Uploads werden immer ausgeführt, unabhängig von der Dateigröße. Dies unterscheidet sich vom Standardverhalten von EMRFS, bei dem die Eigenschaft `fs.s3n.multipart.uploads.split.size` die Dateigröße steuert, in der mehrteilige Uploads ausgelöst werden.
+ Mehrteilige Uploads verbleiben für einen längeren Zeitraum in einem Status, in dem sie nicht abgeschlossen sind, bis die Aufgabe übertragen oder abgebrochen wird. Dies unterscheidet sich von der Standard-Verhalten von EMRFS. Dort wird ein mehrteiliger Upload abgeschlossen, wenn eine Aufgabe den Schreibvorgang für eine bestimmte Datei beendet hat.
Aufgrund dieser Unterschiede vergrößert sich bei mehrteiligen Uploads die Wahrscheinlichkeit, dass unvollständige mehrteilige Uploads zurückbleiben, wenn ein Spark Executor JVM abstürzt oder zerstört wird, während Aufgaben ausgeführt oder Daten auf Amazon S3 oder Spark Driver JVM geschrieben werden. Aus diesem Grund sollten Sie bei Verwendung des S3-optimierten EMRFS-Committer darauf achten, den bewährten Methoden für die Verwaltung von fehlgeschlagenen mehrteiligen Uploads zu folgen. Weitere Informationen finden Sie unter [Bewährte Methoden](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#emr-bucket-bestpractices) für die Arbeit mit Amazon-S3-Buckets im *Verwaltungshandbuch für Amazon EMR*.
# Überlegungen zur Auftragsoptimierung
Auf Spark-Ausführern verbraucht das für EMRFS-S3-optimierte Commit-Protokoll eine geringe Speichermenge für jede Datei, die versuchsweise von einer Aufgabe geschrieben wird, bis die Aufgabe übermittelt oder abgebrochen wird. Bei den meisten Aufträgen ist die Menge des belegten Speichers vernachlässigbar.
Auf Spark-Treibern benötigt das für EMRFS-S3-optimierte Commit-Protokoll Speicher, um die Metadateninformationen jeder übergebenen Datei zu speichern, bis der Auftrags festgeschrieben oder abgebrochen wird. Bei den meisten Aufträgen ist die standardmäßige Speichereinstellung des Spark-Treibers vernachlässigbar.
Bei Aufträgen mit Aufgaben mit langer Laufzeit, die eine große Anzahl von Dateien schreiben, kann der Speicherverbrauch des Commit-Protokolls spürbar sein und Anpassungen des für Spark zugewiesenen Speichers erfordern, insbesondere für Spark-Ausführer. Sie können den Speicher mithilfe der `spark.driver.memory`-Eigenschaft für Spark-Treiber und der Eigenschaft für `spark.executor.memory`-Spark-Aufträge optimieren. Als Faustregel gilt: für jeweils 100.000 Dateien, die eine einzelne Aufgabe schreib, werden in der Regel zusätzlich 100 MB Arbeitsspeicher benötigt. Weiter Informationen finden Sie unter [Anwendungseigenschaften](https://spark.apache.org/docs/latest/configuration.html#application-properties) in der Dokumentation zur Konfiguration von Apache Spark.
# Amazon-S3-Anforderungen mit EMRFS wiederholen
Dieses Thema enthält Informationen zu den Wiederholungsstrategien, die Sie verwenden können, wenn Sie Anforderungen an Amazon S3 mit EMRFS stellen. Wenn Ihre Anforderungsrate steigt, versucht S3, zu skalieren, um die neue Rate zu unterstützen. Während dieses Vorgangs kann S3 Anforderungen drosseln und einen `503 Slow Down`-Fehler zurückgeben. Um die Erfolgsquote Ihrer S3-Anforderungen zu verbessern, können Sie Ihre Wiederholungsstrategie anpassen, indem Sie Eigenschaften in Ihrer `emrfs-site`-Konfiguration konfigurieren.
Sie können Ihre Wiederholungsstrategie wie folgt anpassen.
+ Erhöhen Sie das maximale Wiederholungslimit für die standardmäßige exponentielle Backoff-Wiederholungsstrategie.
+ Aktivieren und konfigurieren Sie die AIMD-Wiederholungsstrategie (additive-increase/multiplicative-decrease). AIMD wird für Amazon-EMR-Versionen 6.4.0 und höher unterstützt.
## Verwenden Sie die standardmäßige exponentielle Backoff-Strategie
Standardmäßig verwendet EMRFS eine exponentielle Backoff-Strategie, um Amazon-S3-Anfragen erneut zu versuchen. Das standardmäßige EMRFS-Wiederholungslimit ist 15. Um einen `503 Slow Down`-S3-Fehler zu vermeiden, können Sie das Wiederholungslimit erhöhen, wenn Sie einen neuen Cluster, in einem laufenden Cluster oder zur Laufzeit der Anwendung erstellen.
Um das Wiederholungslimit zu erhöhen, müssen Sie den Wert für `fs.s3.maxRetries` in Ihrer `emrfs-site`-Konfiguration ändern. Die folgende Beispielkonfiguration setzt `fs.s3.maxRetries` auf einen benutzerdefinierten Wert von 30.
```
[
{
"Classification": "emrfs-site",
"Properties": {
"fs.s3.maxRetries": "30"
}
}
]
```
Weitere Informationen zum Arbeiten mit Konfigurationsobjekten finden Sie unter [Anwendungen konfigurieren](emr-configure-apps.md).
## Verwenden Sie die AIMD-Wiederholungsstrategie
Mit Amazon-EMR-Version 6.4.0 und höher unterstützt EMRFS eine alternative Wiederholungsstrategie, die auf einem AIMD-Modell (Additive-Incree/Multiplicative-Decrease) basiert. Die AIMD-Wiederholungsstrategie ist besonders nützlich, wenn Sie mit großen Amazon-EMR-Clustern arbeiten.
AIMD berechnet anhand von Daten über kürzlich erfolgreiche Anfragen eine benutzerdefinierte Anforderungsrate. Diese Strategie verringert die Anzahl der gedrosselten Anforderungen und die Gesamtzahl der pro Anforderungen erforderlichen Versuche.
Um die AIMD-Wiederholungsstrategie zu aktivieren, müssen Sie die `fs.s3.aimd.enabled`-Eigenschaft in `true` in Ihrer `emrfs-site`-Konfiguration einstellen, wie im folgenden Beispiel gezeigt.
```
[
{
"Classification": "emrfs-site",
"Properties": {
"fs.s3.aimd.enabled": "true"
}
}
]
```
Weitere Informationen zum Arbeiten mit Konfigurationsobjekten finden Sie unter [Anwendungen konfigurieren](emr-configure-apps.md).
## Erweiterte Einstellungen für AIMD-Wiederholungen
Sie können die in der folgenden Tabelle aufgeführten Eigenschaften konfigurieren, um das Wiederholungsverhalten zu verfeinern, wenn Sie die AIMD-Wiederholungsstrategie verwenden. Für die meisten Anwendungsfälle empfehlen wir die Verwendung der Standardeinstellung.
**Erweiterte Eigenschaften der AIMD-Wiederholungsstrategie**
| Eigenschaft | Standardwert | Description |
| --- | --- | --- |
| fs.s3.aimd.increaseIncrement | 0.1 | Steuert, wie schnell die Anforderungsrate steigt, wenn aufeinanderfolgende Anforderungen erfolgreich sind. |
| fs.s3.aimd.reductionFactor | 2 | Steuert, wie schnell die Anforderungsrate sinkt, wenn Amazon S3 eine 503-Antwort zurückgibt. Der Standardfaktor von 2 halbiert die Anforderungsrate. |
| fs.s3.aimd.minRate | 0.1 | Legt die Untergrenze für die Anforderungsrate fest, wenn Anfragen dauerhaft durch S3 gedrosselt werden. |
| fs.s3.aimd.initialRate | 5500 | Legt die anfängliche Anforderungsrate fest, die sich dann entsprechend den Werten ändert, die Sie für fs.s3.aimd.increaseIncrement und fs.s3.aimd.reductionFactor angeben.Die anfängliche Rate wird auch für GET-Anforderungen verwendet und für PUT-Anforderungen proportional (3500/5500) skaliert. |
| fs.s3.aimd.adjustWindow | 2 | Steuert, wie oft die Anforderungsrate angepasst wird, gemessen an der Anzahl der Antworten. |
| fs.s3.aimd.maxAttempts | 100 | Legt die maximale Anzahl der Versuche fest, eine Anforderungen zu versuchen. |
# Einen Spark-Schritt hinzufügen
Sie können mit Amazon-EMR-Schritten Arbeit an das auf einem EMR-Cluster installierte Spark-Framework senden. Weitere Informationen finden Sie unter [Schritte](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html#emr-overview-data-processing) im Verwaltungshandbuch für Amazon EMR. In der Konsole und CLI erfolgt dies mithilfe eines Spark-Anwendungsschritts, der das Skript `spark-submit` als Schritt in Ihrem Namen ausführt. In der API rufen Sie `spark-submit` mithilfe eines Schritts auf und verwenden `command-runner.jar`.
Weitere Informationen zum Senden von Anwendungen an Spark finden Sie im Thema [Bewerbungen einreichen](https://spark.apache.org/docs/latest/submitting-applications.html) in der Apache-Spark-Dokumentation.
**So senden Sie einen Spark-Schritt mithilfe der Konsole**
1. Öffnen Sie die Amazon EMR-Konsole unter [https://console.aws.amazon.com/emr](https://console.aws.amazon.com/emr/).
1. Wählen Sie unter **Cluster List** den Namen Ihres Clusters aus.
1. Scrollen Sie zum Abschnitt **Steps (Schritte)** und erweitern Sie ihn. Wählen Sie anschließend **Add step (Schritt hinzufügen)** aus.
1. Gehen Sie im Dialogfeld **Add Step** folgendermaßen vor:
+ Wählen Sie für **Step type** die Option **Spark application** aus.
+ Übernehmen Sie unter **Name** den Standardnamen ("Spark application") oder geben Sie einen neuen Namen ein.
+ Wählen Sie unter **Deploy mode (Bereitstellungsmodus)** den Modus **Client** oder **Cluster** aus. Der Client-Modus startet das Treiberprogramm in der Primär-Instance des Clusters, während der Cluster-Modus das Treiberprogramm im Cluster startet. Im Clientmodus wird die Protokollausgabe des Treibers in den Schrittprotokollen angezeigt, während im Clustermodus die Protokollausgabe des Treibers in den Protokollen für den ersten YARN-Container angezeigt wird. Weitere Informationen finden Sie unter [Übersicht über den Clustermodus](https://spark.apache.org/docs/latest/cluster-overview.html) in der Apache-Spark-Dokumentation.
+ Geben Sie die gewünschten **spark-submit**-Optionen an. Weitere Informationen zu den `spark-submit`-Optionen finden Sie unter [Starten von Anwendungen mit Spark-Submit](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit).
+ Geben Sie bei **Application location (Anwendungsspeicherort)** den lokalen oder S3-URI-Pfad der Anwendung an.
+ Lassen Sie unter **Arguments (Parameter)** das Feld leer.
+ Übernehmen Sie unter **Action on failure (Aktion bei Fehler)** die Standardeinstellung **Continue (Fortfahren)**.
1. Wählen Sie **Hinzufügen** aus. Der Schritt wird in der Konsole mit dem Status "Pending" angezeigt.
1. Bei Ausführung des Schritts ändert sich dessen Status von **Pending** zu **Running** und **Completed**. Wählen Sie über der Spalte **Actions (Aktionen)** das Symbol **Refresh (Ansicht aktualisieren)** aus, um den Status zu aktualisieren.
1. Die Ergebnisse des Schritts stehen in der Amazon-EMR-Konsole auf der Seite Cluster Details neben dem Schritt unter **Protokolldateien** zur Verfügung, wenn Sie die Protokollierung konfiguriert haben. Optional finden Sie Informationen zum Schritt im Protokoll-Bucket, den Sie beim Start des Clusters konfiguriert haben.
**Um Arbeiten bei Spark einzureichen, verwenden Sie den AWS CLI**
Senden Sie einen Schritt, wenn Sie den Cluster erstellen, oder verwenden Sie den Unterbefehl `aws emr add-steps` in einem vorhandenen Cluster.
1. Verwenden Sie `create-cluster`, wie im folgenden Beispiel gezeigt.
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
```
aws emr create-cluster --name "Add Spark Step Cluster" --release-label emr-7.12.0 --applications Name=Spark \
--ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \
--steps Type=Spark,Name="Spark Program",ActionOnFailure=CONTINUE,Args=[--class,org.apache.spark.examples.SparkPi,/usr/lib/spark/examples/jars/spark-examples.jar,10] --use-default-roles
```
Alternativ können Sie auch `command-runner.jar` verwenden, wie im folgenden Beispiel gezeigt.
```
aws emr create-cluster --name "Add Spark Step Cluster" --release-label emr-7.12.0 \
--applications Name=Spark --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \
--steps Type=CUSTOM_JAR,Name="Spark Program",Jar="command-runner.jar",ActionOnFailure=CONTINUE,Args=[spark-example,SparkPi,10] --use-default-roles
```
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
1. Alternativ können Sie einem bereits ausgeführten Cluster Schritte hinzufügen. Verwenden Sie `add-steps`.
```
aws emr add-steps --cluster-id j-2AXXXXXXGAPLF --steps Type=Spark,Name="Spark Program",ActionOnFailure=CONTINUE,Args=[--class,org.apache.spark.examples.SparkPi,/usr/lib/spark/examples/jars/spark-examples.jar,10]
```
Alternativ können Sie auch `command-runner.jar` verwenden, wie im folgenden Beispiel gezeigt.
```
aws emr add-steps --cluster-id j-2AXXXXXXGAPLF --steps Type=CUSTOM_JAR,Name="Spark Program",Jar="command-runner.jar",ActionOnFailure=CONTINUE,Args=[spark-example,SparkPi,10]
```
**So senden Sie Arbeit mithilfe des SDK für Java an Spark**
1. Das folgende Beispiel zeigt, wie Sie einen Schritt zu einem Cluster mit Spark mittels Java hinzufügt.
```
AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
AmazonElasticMapReduce emr = new AmazonElasticMapReduceClient(credentials);
StepFactory stepFactory = new StepFactory();
AmazonElasticMapReduceClient emr = new AmazonElasticMapReduceClient(credentials);
AddJobFlowStepsRequest req = new AddJobFlowStepsRequest();
req.withJobFlowId("j-1K48XXXXXXHCB");
List stepConfigs = new ArrayList();
HadoopJarStepConfig sparkStepConf = new HadoopJarStepConfig()
.withJar("command-runner.jar")
.withArgs("spark-submit","--executor-memory","1g","--class","org.apache.spark.examples.SparkPi","/usr/lib/spark/examples/jars/spark-examples.jar","10");
StepConfig sparkStep = new StepConfig()
.withName("Spark Step")
.withActionOnFailure("CONTINUE")
.withHadoopJarStep(sparkStepConf);
stepConfigs.add(sparkStep);
req.withSteps(stepConfigs);
AddJobFlowStepsResult result = emr.addJobFlowSteps(req);
```
1. Untersuchen Sie die Protokolle für den Schritt, um die Ergebnisse einzusehen. Sie können dies in der tun, AWS-Managementkonsole sofern Sie die Protokollierung aktiviert haben, indem Sie **Schritte** wählen, Ihren Schritt auswählen und dann für **Protokolldateien** entweder `stdout` oder wählen`stderr`. Wählen Sie **View Logs** aus, um eine Ansicht der verfügbaren Protokoll zu erhalten.
## Überschreiben der standardmäßigen Spark-Konfigurationseinstellungen
Vielleicht möchten Sie die standardmäßigen Spark-Konfigurationswerte je nach Anwendung überschreiben. Sie können dies tun, wenn Sie Anwendungen mithilfe eines Schritts senden, wodurch im Wesentlichen Optionen an `spark-submit` übergeben werden. Sie möchten z. B. den Speicher ändern, der einem Executor-Prozess zugeordnet wurde. Dazu modifizieren Sie `spark.executor.memory`. Dann geben Sie den Schalter `--executor-memory` mit einem Argument wie dem folgenden an:
```
spark-submit --executor-memory 1g --class org.apache.spark.examples.SparkPi /usr/lib/spark/examples/jars/spark-examples.jar 10
```
Auf ähnliche Weise können Sie `--executor-cores` und `--driver-memory` optimieren. In einem Schritt würden Sie die folgenden Argumente bereitstellen:
```
--executor-memory 1g --class org.apache.spark.examples.SparkPi /usr/lib/spark/examples/jars/spark-examples.jar 10
```
Sie können mithilfe der Option `--conf` auch Einstellungen optimieren, die eventuell über keinen integrierten Schalter verfügen. Weitere Informationen zu anderen optimierbaren Einstellungen finden Sie im Thema [Dynamisches Laden von Spark-Eigenschaften](https://spark.apache.org/docs/latest/configuration.html#dynamically-loading-spark-properties) in der Apache-Spark-Dokumentation.
# Anzeigen des Spark-Anwendungsverlaufs
Sie können Spark-, YARN-Anwendungs- und Tez-UI-Details über die Registerkarte **Anwendungsbenutzeroberflächen** auf der Detailseite eines Clusters in der Konsole anzeigen. Die Benutzeroberflächen (UI) der Amazon-EMR-Anwendung erleichtern Ihnen die Fehlerbehebung und Analyse aktiver Jobs und des Jobverlaufs.
Weitere Informationen finden Sie unter [Anwendungsverlauf anzeigen](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-cluster-application-history.html) im *Verwaltungshandbuch für Amazon EMR*.
# Greifen Sie auf das Spark-Web zu UIs
Sie können das Spark-Web aufrufen, UIs indem Sie die Verfahren zum Erstellen eines SSH-Tunnels oder zum Erstellen eines Proxys im Abschnitt [Connect to the Cluster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node.html) im Amazon EMR Management Guide befolgen und dann zum YARN ResourceManager für Ihren Cluster navigieren. Wählen Sie den Link unter **Tracking UI** für Ihre Anwendung aus. Wenn Ihre Anwendung läuft, sehen Sie. **ApplicationMaster** Auf diese Weise gelangen Sie zur Web-Benutzerschnittstelle der Spark-Anwendung auf Port 20888, wo auch immer sich der Treiber befindet. Der Treiber kann sich auf dem Primärknoten des Clusters befinden, wenn Sie den YARN-Clientmodus ausführen. Wenn Sie eine Anwendung im YARN-Clustermodus ausführen, befindet sich der Treiber im ApplicationMaster Ordner für die Anwendung auf dem Cluster. Wenn Ihre Anwendung abgeschlossen ist, wird **Verlauf** angezeigt, der Sie zur HistoryServer Spark-UI-Portnummer 18080 des primären Knotens des EMR-Clusters weiterleitet. Dies gilt für Anwendungen, die bereits abgeschlossen sind. Sie können auch direkt zur HistoryServer Spark-Benutzeroberfläche unter http: //:18080/ navigieren. *master-public-dns-name*
Mit Amazon-EMR-Version 5.25.0 und höher können Sie über die Konsole auf die Benutzeroberfläche des Spark-Historie-Servers zugreifen, ohne einen Web-Proxy über eine SSH-Verbindung einzurichten. Weitere Informationen finden Sie unter [Anzeigen von persistenten Anwendungsbenutzeroberflächen](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html).
# Verwenden des Amazon Kinesis Data Streams-Connectors für strukturiertes Streaming mit Spark
Die Amazon EMR-Versionen 7.1.0 und höher enthalten im Release-Image einen strukturierten Spark-Streaming-Konnektor für Amazon Kinesis Data Streams. Mit diesem Connector können Sie Spark auf Amazon EMR verwenden, um Daten zu verarbeiten, die in Amazon Kinesis Data Streams gespeichert sind. Der Connector unterstützt sowohl Verbrauchertypen `GetRecords` (gemeinsamer Durchsatz) als auch `SubscribeToShard` (erweiterter Fan-Out). Diese Integration basiert auf dem [https://github.com/awslabs/spark-sql-kinesis-connector](https://github.com/awslabs/spark-sql-kinesis-connector). Einzelheiten zu den ersten Schritten mit der Verwendung des Connectors finden Sie in der [README-Datei](https://github.com/awslabs/spark-sql-kinesis-connector/blob/main/README.md).
Das folgende Beispiel zeigt, wie Sie den Connector verwenden, um eine Spark-Anwendung mit Amazon EMR zu starten.
```
spark-submit my_kinesis_streaming_script.py
```
# Amazon-Redshift-Integration für Apache Spark mit Amazon EMR verwenden
Mit Amazon-EMR-Version 6.4.0 und höher enthält jedes Versions-Image einen Konnektor zwischen [Apache Spark](https://aws.amazon.com/emr/features/spark/) und Amazon Redshift. Mit diesem Konnektor können Sie Spark auf Amazon EMR verwenden, um in Amazon Redshift gespeicherte Daten zu verarbeiten. Für die Amazon-EMR-Versionen 6.4.0 bis 6.8.0 basiert die Integration auf dem [`spark-redshift`-Open-Source-Konnektor.](https://github.com/spark-redshift-community/spark-redshift#readme) Für Amazon-EMR-Versionen 6.9.0 und höher wurde die [Amazon-Redshift-Integration für Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) von der Community-Version auf eine native Integration migriert.
**Topics**
+ [Starten einer Spark-Anwendung mithilfe der Amazon-Redshift-Integration für Apache Spark](emr-spark-redshift-launch.md)
+ [Mit der Amazon-Redshift-Integration für Apache Spark authentifizieren](emr-spark-redshift-auth.md)
+ [Lesen und Schreiben von und zu Amazon Redshift](emr-spark-redshift-readwrite.md)
+ [Überlegungen und Einschränkungen bei der Verwendung des Spark-Connectors](emr-spark-redshift-considerations.md)
# Starten einer Spark-Anwendung mithilfe der Amazon-Redshift-Integration für Apache Spark
Für die Amazon-EMR-Versionen 6.4 bis 6.9 müssen Sie die Option `--jars` oder `--packages` verwenden, um anzugeben, welche der folgenden JAR-Dateien Sie verwenden möchten. Die `--jars`-Option gibt Abhängigkeiten an, die lokal, in HDFS oder unter Verwendung von HTTP/S gespeichert sind. Weitere von der `--jars`-Option unterstützte Dateispeicherorte finden Sie unter [Erweitertes Abhängigkeitsmanagement](https://spark.apache.org/docs/latest/submitting-applications.html#advanced-dependency-management) in der Spark-Dokumentation. Die `--packages`-Option spezifiziert Abhängigkeiten, die im öffentlichen Maven-Repository gespeichert sind.
+ `spark-redshift.jar`
+ `spark-avro.jar`
+ `RedshiftJDBC.jar`
+ `minimal-json.jar`
Amazon-EMR-Versionen 6.10.0 und höher erfordern die `minimal-json.jar`-Abhängigkeit nicht und installieren die anderen Abhängigkeiten standardmäßig automatisch in jedem Cluster. Die folgenden Beispiele zeigen, wie Sie eine Spark-Anwendung mit der Amazon-Redshift-Integration für Apache Spark starten.
------
#### [ Amazon EMR 6.10.0 \$1 ]
Das folgende Beispiel zeigt, wie eine Spark-Anwendung mit dem `spark-redshift`-Konnektor mit Amazon-EMR-Versionen 6.10 und höher gestartet wird.
```
spark-submit my_script.py
```
------
#### [ Amazon EMR 6.4.0 - 6.9.x ]
Um eine Spark-Anwendung mit dem `spark-redshift`-Konnektor auf den Amazon-EMR-Versionen 6.4 bis 6.9 zu starten, müssen Sie die Option `--jars` oder `--packages` verwenden, wie das folgende Beispiel zeigt. Beachten Sie, dass die mit der `--jars`-Option aufgeführten Pfade die Standardpfade für die JAR-Dateien sind.
```
spark-submit \
--jars /usr/share/aws/redshift/jdbc/RedshiftJDBC.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-redshift.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-avro.jar,/usr/share/aws/redshift/spark-redshift/lib/minimal-json.jar \
my_script.py
```
------
# Mit der Amazon-Redshift-Integration für Apache Spark authentifizieren
## Wird verwendet AWS Secrets Manager , um Anmeldeinformationen abzurufen und eine Verbindung zu Amazon Redshift herzustellen
Das folgende Codebeispiel zeigt, wie Sie Anmeldeinformationen abrufen können AWS Secrets Manager , um eine Verbindung zu einem Amazon Redshift Redshift-Cluster mit der PySpark Schnittstelle für Apache Spark in Python herzustellen.
```
from pyspark.sql import SQLContext
import boto3
sc = # existing SparkContext
sql_context = SQLContext(sc)
secretsmanager_client = boto3.client('secretsmanager')
secret_manager_response = secretsmanager_client.get_secret_value(
SecretId='string',
VersionId='string',
VersionStage='string'
)
username = # get username from secret_manager_response
password = # get password from secret_manager_response
url = "jdbc:redshift://redshifthost:5439/database?user=" + username + "&password=" + password
# Read data from a table
df = sql_context.read \
.format("io.github.spark_redshift_community.spark.redshift") \
.option("url", url) \
.option("dbtable", "my_table") \
.option("tempdir", "s3://path/for/temp/data") \
.load()
```
## Verwenden Sie IAM, um Anmeldeinformationen abzurufen und eine Verbindung zu Amazon Redshift herzustellen
Sie können den von Amazon Redshift bereitgestellten JDBC-Version 2 verwenden, um mit dem Spark-Konnektor eine Verbindung mit Amazon Redshift herzustellen. Um AWS Identity and Access Management (IAM) zu verwenden, [konfigurieren Sie Ihre JDBC-URL](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-iam-credentials-configure-jdbc-odbc.html) für die Verwendung der IAM-Authentifizierung. Um eine Verbindung zu einem Redshift-Cluster von Amazon EMR herzustellen, müssen Sie Ihrer IAM-Rolle die Berechtigung erteilen, temporäre IAM-Anmeldeinformationen abzurufen. Weisen Sie Ihrer IAM-Rolle die folgenden Berechtigungen zu, damit sie Anmeldeinformationen abrufen und Amazon-S3-Vorgänge ausführen kann.
+ [Redshift: GetClusterCredentials](https://docs.aws.amazon.com/redshift/latest/APIReference/API_GetClusterCredentials.html) (für bereitgestellte Amazon Redshift Redshift-Cluster)
+ [Redshift: DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html) (für bereitgestellte Amazon Redshift Redshift-Cluster)
+ [Redshift: GetWorkgroup](https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_GetWorkgroup.html) (für serverlose Amazon Redshift Redshift-Arbeitsgruppen)
+ [Redshift: GetCredentials](https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_GetCredentials.html) (für serverlose Amazon Redshift Redshift-Arbeitsgruppen)
+ [s3: GetBucket](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetBucket.html)
+ [s3: GetBucketLocation](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLocation.html)
+ [s3: GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)
+ [s3: PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)
+ [s3: GetBucketLifecycleConfiguration](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html)
Weitere Informationen zu `GetClusterCredentials` finden Sie unter [Ressourcenrichtlinien für `GetClusterCredentials`](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#redshift-policy-resources.getclustercredentials-resources).
Sie müssen außerdem sicherstellen, dass Amazon Redshift die IAM-Rolle während `COPY`- und `UNLOAD`-Operationen übernehmen kann.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sts:AssumeRole"
],
"Resource": "arn:aws:iam::123456789012:role/RedshiftServiceRole",
"Sid": "AllowSTSAssumerole"
}
]
}
```
------
Das folgende Beispiel verwendet die IAM-Authentifizierung zwischen Spark und Amazon Redshift:
```
from pyspark.sql import SQLContext
import boto3
sc = # existing SparkContext
sql_context = SQLContext(sc)
url = "jdbc:redshift:iam://redshift-host:redshift-port/db-name"
iam_role_arn = "arn:aws:iam::account-id:role/role-name"
# Read data from a table
df = sql_context.read \
.format("io.github.spark_redshift_community.spark.redshift") \
.option("url", url) \
.option("aws_iam_role", iam_role_arn) \
.option("dbtable", "my_table") \
.option("tempdir", "s3a://path/for/temp/data") \
.mode("error") \
.load()
```
# Lesen und Schreiben von und zu Amazon Redshift
Die folgenden Codebeispiele werden verwendet PySpark , um Beispieldaten von und in eine Amazon Redshift Redshift-Datenbank mit Datenquellen-API und unter Verwendung von SparkSQL zu lesen und zu schreiben.
------
#### [ Data source API ]
Wird verwendet PySpark , um Beispieldaten von und in eine Amazon Redshift Redshift-Datenbank mit Datenquellen-API zu lesen und zu schreiben.
```
import boto3
from pyspark.sql import SQLContext
sc = # existing SparkContext
sql_context = SQLContext(sc)
url = "jdbc:redshift:iam://redshifthost:5439/database"
aws_iam_role_arn = "arn:aws:iam::accountID:role/roleName"
df = sql_context.read \
.format("io.github.spark_redshift_community.spark.redshift") \
.option("url", url) \
.option("dbtable", "tableName") \
.option("tempdir", "s3://path/for/temp/data") \
.option("aws_iam_role", "aws_iam_role_arn") \
.load()
df.write \
.format("io.github.spark_redshift_community.spark.redshift") \
.option("url", url) \
.option("dbtable", "tableName_copy") \
.option("tempdir", "s3://path/for/temp/data") \
.option("aws_iam_role", "aws_iam_role_arn") \
.mode("error") \
.save()
```
------
#### [ SparkSQL ]
Wird verwendet PySpark , um Beispieldaten mit SparkSQL aus und in eine Amazon Redshift Redshift-Datenbank zu lesen und zu schreiben.
```
import boto3
import json
import sys
import os
from pyspark.sql import SparkSession
spark = SparkSession \
.builder \
.enableHiveSupport() \
.getOrCreate()
url = "jdbc:redshift:iam://redshifthost:5439/database"
aws_iam_role_arn = "arn:aws:iam::accountID:role/roleName"
bucket = "s3://path/for/temp/data"
tableName = "tableName" # Redshift table name
s = f"""CREATE TABLE IF NOT EXISTS {tableName} (country string, data string)
USING io.github.spark_redshift_community.spark.redshift
OPTIONS (dbtable '{tableName}', tempdir '{bucket}', url '{url}', aws_iam_role '{aws_iam_role_arn}' ); """
spark.sql(s)
columns = ["country" ,"data"]
data = [("test-country","test-data")]
df = spark.sparkContext.parallelize(data).toDF(columns)
# Insert data into table
df.write.insertInto(tableName, overwrite=False)
df = spark.sql(f"SELECT * FROM {tableName}")
df.show()
```
------
# Überlegungen und Einschränkungen bei der Verwendung des Spark-Connectors
+ Wir empfehlen, SSL für die JDBC-Verbindung von Spark auf Amazon EMR zu Amazon Redshift zu aktivieren.
+ Als bewährte Methode empfehlen wir Ihnen, die Anmeldeinformationen für den Amazon-Redshift-Cluster in AWS Secrets Manager zu verwalten. Ein Beispiel finden Sie [unter Verwenden AWS Secrets Manager zum Abrufen von Anmeldeinformationen für die Verbindung mit Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration.html).
+ Wir empfehlen, dass Sie eine IAM-Rolle mit dem Parameter `aws_iam_role` für den Amazon-Redshift-Authentifizierungsparameter zu übergeben.
+ Die `tempdir`-URI verweist auf einen Amazon-S3-Speicherort. Dieses temporäre Verzeichnis wird nicht automatisch bereinigt und kann zusätzliche Kosten verursachen.
+ Beachten Sie die folgenden Empfehlungen für Amazon Redshift:
+ Wir empfehlen, den öffentlichen Zugriff auf den Amazon-Redshift-Cluster zu blockieren.
+ Wir empfehlen, die [Amazon-Redshift-Auditprotokollierung](https://docs.aws.amazon.com/redshift/latest/mgmt/db-auditing.html) zu aktivieren.
+ Wir empfehlen Ihnen die [Amazon-Redshift-Verschlüsselung im Ruhezustand](https://docs.aws.amazon.com/redshift/latest/mgmt/security-server-side-encryption.html) zu aktivieren.
+ Beachten Sie die folgenden Empfehlungen für Amazon S3:
+ Wir empfehlen Ihnen [den öffentlichen Zugriff auf Amazon-S3-Buckets zu blockieren](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-control-block-public-access.html).
+ Wir empfehlen die Verwendung der [serverseitigen Amazon-S3-Verschlüsselung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html), um die verwendeten Amazon-S3-Buckets zu verschlüsseln.
+ Wir empfehlen, die [Lebenszyklusrichtlinien für Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) zu verwenden, um die Aufbewahrungsregeln für den Amazon-S3-Bucket zu definieren.
+ Amazon EMR überprüft immer Code, der aus Open Source in das Image importiert wurde. Aus Sicherheitsgründen unterstützen wir die folgenden Authentifizierungsmethoden von Spark für Amazon S3 nicht:
+ AWS Zugriffstasten in der `hadoop-env` Konfigurationsklassifizierung einrichten
+ Kodierung der AWS Zugriffsschlüssel in der `tempdir` URI
Weitere Informationen zum Verwenden des Konnektors und seiner unterstützten Parameter finden Sie in den folgenden Ressourcen:
+ [Amazon-Redshift-Integration für Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) im *Amazon-Redshift-Verwaltungshandbuch*
+ Das [`spark-redshift`-Community-Repository](https://github.com/spark-redshift-community/spark-redshift#readme) auf Github
# Spark-Versionsverlauf
In der folgenden Tabelle sind die Versionen von Spark aufgeführt, die in jeder Release-Version von Amazon EMR enthalten ist, zusammen mit den Komponenten, die mit der Anwendung installiert wurden. Informationen zu den Komponentenversionen in den einzelnen Versionen finden Sie im Abschnitt Komponentenversion für Ihre Version in [Amazon-EMR-7.x-Versionen](emr-release-7x.md), [Amazon-EMR-6.x-Versionen](emr-release-6x.md) oder [Amazon-EMR-5.x-Versionen](emr-release-5x.md).
**Wichtig**
Apache-Spark-Version 2.3.1, verfügbar ab Amazon-EMR-Version 5.16.0, adressiert [CVE-2018-8024](https://nvd.nist.gov/vuln/detail/CVE-2018-8024) und [CVE-2018-1334.](https://nvd.nist.gov/vuln/detail/CVE-2018-1334) Wir empfehlen, dass Sie frühere Versionen von Spark zu Spark-Version 2.3.1 oder höher migrieren.
**Die Spark Versionsinformationen**
| Amazon-EMR-Versionsbezeichnung | Spark-Version | Mit Spark installierte Komponenten |
| --- | --- | --- |
| emr-7.12.0 | 3.5.6-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.11.0 | 3.5.6-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.10.0 | 3.5.5-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.9.0 | 3.5.5-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.8.0 | 3.5.4-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.7.0 | 3.5.3-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.6.0 | 3.5.3-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.5.0 | 3.5.2-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.4.0 | 3.5.2-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.3.0 | 3.5.1-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.2.0 | 3.5.1-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.36,2 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.1.0 | 3.5.0-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.0.0 | 3.5.0-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.15.0 | 3.4.1-amzn-2 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.14.0 | 3.4.1-amzn-1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.13.0 | 3.4.1-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.12.0 | 3.4.0-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.11.1 | 3.3.2-amzn-0.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.11.0 | 3.3.2-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.10.1 | 3.3.1-amzn-0.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.10.0 | 3.3.1-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.9.1 | 3.3.0-amzn-1.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.9.0 | 3.3.0-amzn-1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.8.1 | 3.3.0-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.8.0 | 3.3.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.7.0 | 3.2.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.36.1 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.36.0 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.6.0 | 3.2.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.35.0 | 2.4.8-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.5.0 | 3.1.2-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.4.0 | 3.1.2-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.3.1 | 3.1.1-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.3.0 | 3.1.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.2.1 | 3.0.1-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.2.0 | 3.0.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.1.1 | 3.0.0-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.1.0 | 3.0.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.0.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.0.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.34.0 | 2.4.8-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.33.1 | 2.4.7-amzn-1.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.33.0 | 2.4.7-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.32.1 | 2.4.7-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.32.0 | 2.4.7-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.31.1 | 2.4.6-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.31.0 | 2.4.6-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.30.2 | 2.4.5-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.30.1 | 2.4.5-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.30.0 | 2.4.5-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-notebook-env, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.29.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.28.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.28.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.27.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.27.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.26.0 | 2.4.3 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.25.0 | 2.4.3 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.24.1 | 2.4.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.24.0 | 2.4.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.23.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.23.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.22.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.21.2 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.21.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.21.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.20.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.20.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.19.1 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.19.0 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.18.1 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.18.0 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.17.2 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.17.1 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.17.0 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.16.1 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.16.0 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.15.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.15.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.14.2 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.14.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.14.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.13.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.13.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.12.3 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.12.2 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.12.1 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.12.0 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.4 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.3 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.2 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.1 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.0 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.10.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.10.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.9.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.9.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.8.3 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.8.2 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.8.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.8.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.7.1 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.7.0 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.6.1 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.6.0 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.4 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.3 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.2 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.4.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.4.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.3.2 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.3.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.3.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.2.3 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.2.2 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.2.1 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.2.0 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.1.1 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.1.0 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.0.3 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.0.2 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.0.1 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.0.0 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.6 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.5 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.4 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.3 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.2 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.1 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.5 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.4 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.3 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.2 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.1 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.0 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.4 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.3 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.2 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.1 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.6.1 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.6.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.5.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.4.0 | 1.6.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.3.0 | 1.6.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.2.0 | 1.5.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.1.0 | 1.5.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.0.0 | 1.4.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
# Materialisierte Ansichten mit Amazon EMR verwenden
Amazon EMR Version 7.12.0 und höher unterstützt die Erstellung und Verwaltung materialisierter Apache Iceberg-Ansichten im Glue-Datenkatalog. AWS Eine materialisierte Ansicht ist eine verwaltete Tabelle, die das vorberechnete Ergebnis einer SQL-Abfrage im Apache Iceberg-Format speichert und schrittweise aktualisiert wird, wenn sich die zugrunde liegenden Quelltabellen ändern. Sie können materialisierte Ansichten verwenden, um Pipelines zur Datentransformation zu vereinfachen und die Abfrageleistung für komplexe analytische Workloads zu beschleunigen.
Wenn Sie mit Spark auf Amazon EMR eine materialisierte Ansicht erstellen, werden die Ansichtsdefinition und die Metadaten im AWS Glue-Datenkatalog gespeichert. Die vorberechneten Ergebnisse werden als Apache Iceberg-Tabellen in Amazon S3 S3-Tabelles-Buckets oder Amazon S3 S3-Allzweck-Buckets in Ihrem Konto gespeichert. AWS Der AWS Glue-Datenkatalog überwacht automatisch Quelltabellen und aktualisiert materialisierte Ansichten mithilfe einer verwalteten Recheninfrastruktur.
**Topics**
+ [So funktionieren materialisierte Ansichten mit Amazon EMR](#emr-spark-materialized-views-how-it-works)
+ [Voraussetzungen](#emr-spark-materialized-views-prerequisites)
+ [Konfiguration von Spark für die Verwendung materialisierter Ansichten](#emr-spark-materialized-views-configure)
+ [Erstellen von materialisierten Ansichten](#emr-spark-materialized-views-create)
+ [Abfragen materialisierter Ansichten](#emr-spark-materialized-views-query)
+ [Aktualisieren materialisierter Ansichten](#emr-spark-materialized-views-refresh)
+ [Materialisierte Ansichten verwalten](#emr-spark-materialized-views-manage)
+ [Berechtigungen für materialisierte Ansichten](#emr-spark-materialized-views-permissions)
+ [Überwachung von Materialized View-Vorgängen](#emr-spark-materialized-views-monitoring)
+ [Beispiel: Vollständiger Workflow](#emr-spark-materialized-views-example)
+ [Überlegungen und Einschränkungen](#emr-spark-materialized-views-limitations)
## So funktionieren materialisierte Ansichten mit Amazon EMR
Materialisierte Ansichten lassen sich über die Iceberg-Unterstützung von Apache Spark in Amazon EMR integrieren. Wenn Sie Ihre Spark-Sitzung für die Verwendung des AWS Glue-Datenkatalogs konfigurieren, können Sie materialisierte Ansichten mithilfe der Standard-SQL-Syntax erstellen. Der Spark-Optimierer kann Abfragen automatisch so umschreiben, dass sie materialisierte Ansichten verwenden, wenn sie eine bessere Leistung bieten, sodass der Anwendungscode nicht manuell geändert werden muss.
Der AWS Glue-Datenkatalog behandelt alle betrieblichen Aspekte der Wartung von Materialized Views, einschließlich:
+ Erkennung von Änderungen in Quelltabellen mithilfe der Metadatenebene von Apache Iceberg
+ Planung und Ausführung von Aktualisierungsvorgängen mithilfe von Managed Spark Compute
+ Feststellen, ob auf der Grundlage der Datenänderungen eine vollständige oder eine inkrementelle Aktualisierung durchgeführt werden soll
+ Speichern vorberechneter Ergebnisse im Apache Iceberg-Format für den Zugriff mit mehreren Engines
Sie können materialisierte Ansichten von Amazon EMR mit denselben Spark-SQL-Schnittstellen abfragen, die Sie für normale Tabellen verwenden. Auf die vorberechneten Daten kann auch von anderen Diensten wie Amazon Athena und Amazon Redshift aus zugegriffen werden.
## Voraussetzungen
Um materialisierte Ansichten mit Amazon EMR zu verwenden, benötigen Sie:
+ Ein Konto AWS
+ Ein Amazon EMR-Cluster, auf dem Version 7.12.0 oder höher ausgeführt wird
+ Quelltabellen im Apache Iceberg-Format, registriert im AWS Glue Data Catalog
+ AWS Lake Formation Formation-Berechtigungen, die für Quelltabellen und Zieldatenbanken konfiguriert sind
+ Ein bei AWS Lake Formation registrierter S3 Tables-Bucket oder S3-Allzweck-Bucket zum Speichern von materialisierten View-Daten
## Konfiguration von Spark für die Verwendung materialisierter Ansichten
Um materialisierte Ansichten zu erstellen und zu verwalten, konfigurieren Sie Ihre Spark-Sitzung mit den erforderlichen Iceberg-Erweiterungen und Katalogeinstellungen. Die Konfiguration hängt davon ab, ob Ihre Quelltabellen und materialisierten Ansichten S3-Tabellen-Buckets oder S3-Allzweck-Buckets verwenden.
### Konfiguration für S3-Tabellen
Wenn Sie S3-Tabelles-Buckets für materialisierte Ansichten verwenden, konfigurieren Sie separate Katalogverweise für Ihre Quelltabellen und materialisierten Ansichten:
```
spark-sql \
--conf 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.type=glue \
--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \
--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \
--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \
--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 \
--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true \
--conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.s3t_catalog.type=glue \
--conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket \
--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 \
--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true \
--conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse \
--conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 \
--conf spark.sql.defaultCatalog=s3t_catalog \
// turn on automatic query rewrite (optional)
--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true
```
### Konfiguration für S3-Allzweck-Buckets
Wenn Sie S3-Allzweck-Buckets verwenden, konfigurieren Sie eine einzelne Katalogreferenz:
```
spark-sql \
--conf 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.type=glue \
--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \
--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \
--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \
--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 \
--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true \
--conf spark.sql.defaultCatalog=glue_catalog \
// turn on automatic query rewrite (optional)
--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true
```
### Aktivierung der inkrementellen Aktualisierung
Um die inkrementelle Aktualisierungsoptimierung zu aktivieren, fügen Sie Ihrer Spark-Sitzung die folgenden Konfigurationseigenschaften hinzu:
```
spark-sql \
--conf spark.sql.optimizer.incrementalMVRefresh.enabled=true \
```
### Konfigurationsparameter
Die folgenden Konfigurationsparameter steuern das Verhalten der materialisierten Ansicht:
+ `spark.sql.extensions`— Aktiviert Iceberg Spark-Sitzungserweiterungen, die für die Unterstützung von Materialized Views erforderlich sind.
+ `spark.sql.optimizer.answerQueriesWithMVs.enabled`— Ermöglicht das automatische Umschreiben von Abfragen zur Verwendung materialisierter Ansichten. Auf true setzen, um diese Optimierung zu aktivieren.
+ `spark.sql.optimizer.incrementalMVRefresh.enabled`— Aktiviert die inkrementelle Aktualisierungsoptimierung. Auf true setzen, um nur geänderte Daten während Aktualisierungsvorgängen zu verarbeiten.
## Erstellen von materialisierten Ansichten
Sie erstellen materialisierte Ansichten mit der SQL-Anweisung CREATE MATERIALIZED VIEW. Die View-Definition spezifiziert die Transformationslogik als eine SQL-Abfrage, die auf eine oder mehrere Quelltabellen verweist.
### DLLs
**Ansicht erstellen**
```
{ CREATE OR REPLACE MATERIALIZED VIEW | CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] }
view_identifier
[ view_clauses ]
[ schedule_clauses ]
AS [ select_statement ]
view_clauses =
{ [ LOCATION location ] |
[ PARTITIONED BY (col [, ...]) ] |
[ COMMENT view_comment ] |
[ SCHEDULE [ REFRESH ] schedule_clause ] }
schedule_clause =
{ EVERY number { HOUR | HOURS | DAY | DAYS | WEEK | WEEKS } }
```
**Anmerkung**
Die view\$1clauses müssen vor dem select\$1statement stehen.
### Eine materialisierte Basisansicht erstellen
Im folgenden Beispiel wird eine materialisierte Ansicht erstellt, die Bestelldaten nach Kunden aggregiert. Verwenden Sie in der Ansichtsdefinition vollständig qualifizierte Tabellennamen mit dreiteiliger Benennungskonvention:
```
CREATE MATERIALIZED VIEW customer_orders
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```
### Erstellen einer materialisierten Ansicht mit automatischer Aktualisierung
Um die automatische Aktualisierung zu konfigurieren, geben Sie beim Erstellen der Ansicht einen Aktualisierungszeitplan an. Verwenden Sie dabei vollqualifizierte Tabellennamen mit dreiteiliger Benennungskonvention in der Ansichtsdefinition:
```
CREATE MATERIALIZED VIEW customer_orders
SCHEDULE REFRESH EVERY 1 HOUR
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```
### Erstellen einer materialisierten Ansicht mit katalogübergreifenden Verweisen
Wenn sich Ihre Quelltabellen in einem anderen Katalog als Ihre materialisierte Ansicht befinden, verwenden Sie vollqualifizierte Tabellennamen mit dreiteiliger Benennungskonvention sowohl im Ansichtsnamen als auch in der Ansichtsdefinition:
```
CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```
## Abfragen materialisierter Ansichten
Nachdem Sie eine materialisierte Ansicht erstellt haben, können Sie sie wie jede andere Tabelle mit den Standard-SQL-SELECT-Anweisungen abfragen:
```
SELECT * FROM customer_orders;
```
### Automatisches Umschreiben von Abfragen
Wenn das automatische Umschreiben von Abfragen aktiviert ist, analysiert der Spark-Optimierer Ihre Abfragen und verwendet automatisch materialisierte Ansichten, wenn diese die Leistung verbessern können. Wenn Sie beispielsweise die folgende Abfrage ausführen:
```
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM orders
GROUP BY customer_name;
```
Der Spark-Optimierer schreibt diese Abfrage automatisch neu, sodass sie die materialisierte Ansicht customer\$1orders verwendet, anstatt die Tabelle mit den Basisbestellungen zu verarbeiten, vorausgesetzt, die materialisierte Ansicht ist aktuell.
### Überprüfung des automatischen Umschreibens von Abfragen
Verwenden Sie den Befehl EXPLAIN EXTENDED, um zu überprüfen, ob eine Abfrage das automatische Umschreiben von Abfragen verwendet:
```
EXPLAIN EXTENDED
SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount
FROM orders
GROUP BY customer_name;
```
Suchen Sie im Ausführungsplan nach dem Namen der materialisierten Ansicht in der BatchScan Operation. Wenn der Plan BatchScan glue\$1catalog.analytics.customer\$1orders statt glue\$1catalog.sales.orders anzeigt, wurde die Abfrage automatisch so umgeschrieben, dass sie die BatchScan materialisierte Ansicht verwendet.
**Anmerkung**
Das automatische Umschreiben von Abfragen benötigt Zeit, bis der Spark-Metadatencache nach dem Erstellen einer materialisierten Ansicht gefüllt ist. Dieser Vorgang ist in der Regel innerhalb von 30 Sekunden abgeschlossen.
## Aktualisieren materialisierter Ansichten
Sie können materialisierte Ansichten mit zwei Methoden aktualisieren: vollständige Aktualisierung oder inkrementelle Aktualisierung. Bei der vollständigen Aktualisierung wird die gesamte materialisierte Ansicht anhand aller Basistabellendaten neu berechnet, während bei der inkrementellen Aktualisierung nur die Daten verarbeitet werden, die sich seit der letzten Aktualisierung geändert haben.
### Manuelle vollständige Aktualisierung
So führen Sie eine vollständige Aktualisierung einer materialisierten Ansicht durch:
```
REFRESH MATERIALIZED VIEW customer_orders FULL;
```
Nachdem Sie diesen Befehl ausgeführt haben, fragen Sie die materialisierte Ansicht ab, um die aktualisierten Ergebnisse zu überprüfen:
```
SELECT * FROM customer_orders;
```
### Manuelles inkrementelles Aktualisieren
Um eine inkrementelle Aktualisierung durchzuführen, stellen Sie sicher, dass die inkrementelle Aktualisierung in Ihrer Spark-Sitzungskonfiguration aktiviert ist, und führen Sie dann Folgendes aus:
```
REFRESH MATERIALIZED VIEW customer_orders;
```
Der AWS Glue-Datenkatalog bestimmt anhand der Ansichtsdefinition und der Menge der geänderten Daten automatisch, ob eine inkrementelle Aktualisierung möglich ist. Wenn eine inkrementelle Aktualisierung nicht möglich ist, wird der Vorgang auf eine vollständige Aktualisierung zurückgesetzt.
### Die Ausführung der inkrementellen Aktualisierung wird überprüft
Um zu überprüfen, ob die inkrementelle Aktualisierung erfolgreich ausgeführt wurde, können Sie die `lastRefreshType` Tabelleneigenschaften überprüfen, indem Sie die folgenden Befehle ausführen:
```
SHOW TBLPROPERTIES ("lastRefreshType")
```
Dies kann auch erreicht werden, indem Sie die Debug-Protokollierung aktivieren, indem Sie Ihre Spark-Log-Konfiguration ändern:
1. Öffnen Sie die Spark log4j-Konfigurationsdatei:
```
sudo vim /usr/lib/spark/conf/log4j2.properties
```
1. Fügen Sie die folgenden Logger-Konfigurationen hinzu:
```
logger.spark.name = org.apache.spark.sql
logger.spark.level = debug
logger.inmemcache.name = org.apache.spark.sql.InMemMvMetadataCache
logger.inmemcache.level = off
```
1. Suchen Sie nach der Ausführung eines Aktualisierungsvorgangs in der Spark-Ausgabe nach der folgenden Meldung:
```
DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh
```
## Materialisierte Ansichten verwalten
Amazon EMR bietet SQL-Befehle für die Verwaltung des Lebenszyklus materialisierter Ansichten.
### Beschreibung einer materialisierten Ansicht
So zeigen Sie Metadaten zu einer materialisierten Ansicht an, einschließlich ihrer Definition, ihres Aktualisierungsstatus und des Zeitstempels der letzten Aktualisierung:
```
DESCRIBE EXTENDED customer_orders;
```
### Eine materialisierte Ansicht ändern
So ändern Sie den Aktualisierungszeitplan einer vorhandenen materialisierten Ansicht:
```
ALTER MATERIALIZED VIEW customer_orders
ADD SCHEDULE REFRESH EVERY 2 HOURS;
```
Um die automatische Aktualisierung zu entfernen:
```
ALTER MATERIALIZED VIEW customer_orders
DROP SCHEDULE;
```
### Löschen einer materialisierten Ansicht
Um eine materialisierte Ansicht zu löschen:
```
DROP MATERIALIZED VIEW customer_orders;
```
Dieser Befehl entfernt die Definition der materialisierten Ansicht aus dem AWS Glue-Datenkatalog und löscht die zugrunde liegenden Iceberg-Tabellendaten aus Ihrem S3-Bucket.
## Berechtigungen für materialisierte Ansichten
Um materialisierte Ansichten zu erstellen und zu verwalten, müssen Sie AWS Lake Formation Formation-Berechtigungen konfigurieren. Die IAM-Rolle, die die materialisierte Ansicht erstellt (die Definer-Rolle), erfordert spezielle Berechtigungen für Quelltabellen und Zieldatenbanken.
### Erforderliche Berechtigungen für die Definer-Rolle
Die Definiererrolle muss über die folgenden Lake Formation Formation-Berechtigungen verfügen:
+ Für Quelltabellen — SELECT- oder ALL-Berechtigungen ohne Zeilen-, Spalten- oder Zellenfilter
+ In der Zieldatenbank — CREATE\$1TABLE-Berechtigung
+ Über den AWS Glue-Datenkatalog — GetTable und CreateTable API-Berechtigungen
Wenn Sie eine materialisierte Ansicht erstellen, wird der ARN der Definiererrolle in der Ansichtsdefinition gespeichert. Der AWS Glue-Datenkatalog übernimmt diese Rolle bei der Ausführung automatischer Aktualisierungsvorgänge. Wenn die Definer-Rolle den Zugriff auf Quelltabellen verliert, schlagen Aktualisierungsvorgänge fehl, bis die Berechtigungen wiederhergestellt sind.
### Zugriff auf materialisierte Ansichten gewähren
Um anderen Benutzern Zugriff auf die Abfrage einer materialisierten Ansicht zu gewähren, verwenden Sie AWS Lake Formation, um die SELECT-Berechtigung für die Materialized View-Tabelle zu erteilen. Benutzer können die materialisierte Ansicht abfragen, ohne direkten Zugriff auf die zugrunde liegenden Quelltabellen zu benötigen.
Ausführliche Informationen zur Konfiguration von Lake Formation-Berechtigungen finden Sie unter Gewähren und Widerrufen von Berechtigungen für Datenkatalogressourcen im AWS Lake Formation Developer Guide.
## Überwachung von Materialized View-Vorgängen
Der AWS Glue-Datenkatalog veröffentlicht Metriken und Protokolle für Aktualisierungsvorgänge von Materialized Views auf Amazon CloudWatch. Sie können den Aktualisierungsstatus, die Dauer und das verarbeitete Datenvolumen anhand von CloudWatch Metriken überwachen.
### Aktualisierungsmetriken anzeigen
So zeigen Sie die Aktualisierungsmetriken für materialisierte Ansichten an:
1. Öffnen Sie die CloudWatch Konsole.
1. Wählen Sie im Navigationsbereich Metriken aus.
1. Wählen Sie den Glue-Namespace.
1. Filtern Sie Metriken nach dem Namen der materialisierten Ansicht.
### Alarme einrichten
Um Benachrichtigungen zu erhalten, wenn Aktualisierungsvorgänge fehlschlagen oder die erwartete Dauer überschreiten, erstellen Sie CloudWatch Alarme für Materialized View-Metriken. Sie können EventBridge Amazon-Regeln auch so konfigurieren, dass automatische Antworten auf Aktualisierungsereignisse ausgelöst werden.
## Beispiel: Vollständiger Workflow
Das folgende Beispiel zeigt einen vollständigen Workflow für die Erstellung und Verwendung einer materialisierten Ansicht in Amazon EMR.
1. Stellen Sie über SSH Connect zu Ihrem primären EMR-Clusterknoten her.
1. Erstellen Sie eine Basistabelle mit Beispieldaten:
```
spark-sql \
--conf 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.type=glue \
--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \
--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \
--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \
--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 \
--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true \
--conf spark.sql.defaultCatalog=glue_catalog \
--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true
CREATE DATABASE IF NOT EXISTS sales;
USE sales;
CREATE TABLE orders (
id INT,
customer_name STRING,
amount DECIMAL(10,2),
order_date DATE
);
INSERT INTO orders VALUES
(1, 'John Doe', 150.00, DATE('2024-01-15')),
(2, 'Jane Smith', 200.50, DATE('2024-01-16')),
(3, 'Bob Johnson', 75.25, DATE('2024-01-17'));
```
1. Erstellen Sie eine materialisierte Ansicht:
```
CREATE MATERIALIZED VIEW customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```
1. Fragen Sie die materialisierte Ansicht ab:
```
SELECT * FROM customer_summary;
```
1. Fügen Sie zusätzliche Daten in die Basistabelle ein:
```
INSERT INTO orders VALUES
(4, 'Jane Smith', 350.00, DATE('2024-01-18')),
(5, 'Bob Johnson', 100.25, DATE('2024-01-19'));
```
1. Aktualisieren Sie die materialisierte Ansicht:
```
REFRESH MATERIALIZED VIEW customer_summary FULL;
```
1. Überprüfen Sie die aktualisierten Ergebnisse:
```
SELECT * FROM customer_summary;
```
## Überlegungen und Einschränkungen
Beachten Sie Folgendes, wenn Sie materialisierte Ansichten mit Amazon EMR verwenden:
+ Materialisierte Ansichten erfordern Amazon EMR Version 7.12.0 oder höher.
+ Quelltabellen müssen Apache Iceberg-Tabellen sein, die im AWS Glue-Datenkatalog registriert sind. Apache Hive-, Apache Hudi- und Delta Lake-Tabellen der Linux Foundation werden beim Start nicht unterstützt.
+ Quelltabellen müssen sich in derselben AWS Region und demselben AWS Konto wie die materialisierte Ansicht befinden.
+ Alle Quelltabellen müssen von AWS Lake Formation verwaltet werden. Reine IAM-Berechtigungen und hybrider Zugriff werden nicht unterstützt.
+ Materialisierte Ansichten können nicht auf AWS Glue Data Catalog-Ansichten, Multidialektansichten oder andere materialisierte Ansichten als Quelltabellen verweisen.
+ Die Rolle des View Definers muss vollen Lesezugriff (SELECT- oder ALL-Berechtigung) auf alle Quelltabellen haben, ohne dass Zeilen-, Spalten- oder Zellfilter angewendet werden.
+ Materialisierte Ansichten stimmen letztendlich mit Quelltabellen überein. Während des Aktualisierungsfensters können Abfragen veraltete Daten zurückgeben. Führen Sie die manuelle Aktualisierung aus, um sofortige Konsistenz zu gewährleisten.
+ Das minimale automatische Aktualisierungsintervall beträgt eine Stunde.
+ Die inkrementelle Aktualisierung unterstützt eine eingeschränkte Teilmenge von SQL-Vorgängen. Die Viewdefinition muss ein einzelner SELECT-FROM-WHERE-GROUP BY-HAVING-Block sein und darf keine Mengenoperationen, Unterabfragen, das DISTINCT-Schlüsselwort in SELECT oder Aggregatfunktionen, Fensterfunktionen oder Joins außer INNER JOIN enthalten.
+ Die inkrementelle Aktualisierung unterstützt keine benutzerdefinierten Funktionen oder bestimmte integrierte Funktionen. Nur eine Teilmenge der integrierten Funktionen von Spark SQL wird unterstützt.
+ Beim automatischen Umschreiben von Abfragen werden nur materialisierte Ansichten berücksichtigt, deren Definitionen zu einer eingeschränkten SQL-Teilmenge gehören, was den Beschränkungen für inkrementelle Aktualisierungen ähnelt.
+ Vollständige Aktualisierungsvorgänge überschreiben die gesamte Tabelle und machen vorherige Snapshots nicht verfügbar.
+ Bezeichner, die andere Sonderzeichen als alphanumerische Zeichen und Unterstriche enthalten, werden in CREATE MATERIALIZED VIEW-Abfragen nicht unterstützt.
+ Spalten in materialisierten Ansichten, die mit dem Präfix \$1\$1ivm beginnen, sind für die Verwendung durch das System reserviert. AWS behält sich das Recht vor, diese Spalten in future Versionen zu ändern oder zu entfernen.
+ Die Klauseln SORT BY, LIMIT, OFFSET, CLUSTER BY und ORDER BY werden in Definitionen materialisierter Ansichten nicht unterstützt.
+ Regions- und kontenübergreifende Quelltabellen werden nicht unterstützt.
+ Nichtdeterministische Funktionen wie rand () oder current\$1timestamp () werden in Definitionen materialisierter Ansichten nicht unterstützt.