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.

# Spark-Anwendungen mit Docker mithilfe von Amazon EMR 6.x ausführen
<a name="emr-spark-docker"></a>

**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
<a name="emr-spark-docker-considerations"></a>

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\_CONTAINER\_RUNTIME\_DOCKER\_CLIENT\_CONFIG= {DOCKER\_CLIENT\_CONFIG\_PATH\_ON\_HDFS}
+ 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
<a name="emr-spark-docker-image"></a>

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
<a name="emr-spark-docker-ECR"></a>

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**

Im folgenden Beispiel wird das PySpark Dockerfile verwendet, 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:
```