Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejecución de aplicaciones de Spark con Docker en Amazon EMR 6.x
<a name="emr-spark-docker"></a>

**nota**  
El procedimiento descrito en esta sección solo aplica a Amazon EMR versión 6.x.

Con Amazon EMR 6.0.0, las aplicaciones de Spark pueden utilizar contenedores de Docker para definir sus dependencias de biblioteca, en lugar de instalar dependencias en las instancias de Amazon EC2 individuales del clúster. Para ejecutar Spark con Docker, primero debe configurar el registro de Docker y definir parámetros adicionales al enviar una aplicación Spark. Para obtener más información, consulte [Configuración de la integración de Docker](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).

Cuando se envía la aplicación, YARN invoca Docker para extraer la imagen de Docker especificada y ejecutar la aplicación Spark dentro de un contenedor de Docker. Esto le permite definir y aislar fácilmente las dependencias. Reduce la duración del proceso de arranque o preparación de las instancias en el clúster de Amazon EMR con las bibliotecas necesarias para la ejecución del trabajo. 

## Consideraciones al ejecutar Spark con Docker
<a name="emr-spark-docker-considerations"></a>

Cuando ejecute Spark con Docker, asegúrese de que se cumplen los siguientes requisitos previos:
+ El paquete `docker` y la CLI solo deben estar instalados en los nodos principales y de tareas.
+ En la versión 6.1.0 y posteriores de Amazon EMR, también puede instalar Docker en un nodo principal con los siguientes comandos.
  + 

    ```
    sudo yum install -y docker
    sudo systemctl start docker
    ```
+ El comando `spark-submit` siempre debe ejecutarse desde una instancia principal en el clúster de Amazon EMR.
+ Los registros de Docker utilizados con el fin de resolver imágenes de Docker deben definirse mediante la API de clasificación con la clave de clasificación `container-executor` para definir parámetros adicionales al iniciar el clúster:
  + `docker.trusted.registries`
  + `docker.privileged-containers.registries`
+ Para ejecutar una aplicación Spark en un contenedor de Docker, son necesarias las siguientes opciones de configuración:
  + `YARN_CONTAINER_RUNTIME_TYPE=docker`
  + `YARN_CONTAINER_RUNTIME_DOCKER_IMAGE={DOCKER_IMAGE_NAME}`
+ Cuando utilice Amazon ECR para recuperar imágenes de Docker, debe configurar el clúster de tal forma que se autentique por sí solo. Para ello, debe utilizar la siguiente opción de configuración:
  + YARN\$1CONTAINER\$1RUNTIME\$1DOCKER\$1CLIENT\$1CONFIG=\$1DOCKER\$1CLIENT\$1CONFIG\$1PATH\$1ON\$1HDFS\$1
+ En la versión 6.1.0 y posteriores de Amazon EMR, no es necesario utilizar el comando indicado `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG={DOCKER_CLIENT_CONFIG_PATH_ON_HDFS}` cuando la característica de autenticación automática de ECR está habilitada.
+ Cualquier imagen de Docker utilizada con Spark debe tener Java instalado en la imagen de Docker.

Para obtener más información acerca de los requisitos previos, consulte [Configurar la integración de Docker](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).

## Creación de una imagen de Docker
<a name="emr-spark-docker-image"></a>

Las imágenes de Docker se crean utilizando un archivo Dockerfile, que define los paquetes y la configuración que se van a incluir en la imagen. Los siguientes dos ejemplos de Dockerfiles utilizan y PySpark SparkR.

**PySpark Dockerfile**

Las imágenes de Docker creadas a partir de este Dockerfile incluyen Python 3 y el paquete Python NumPy . Este archivo Dockerfile utiliza Amazon Linux 2 y 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"
```

**Archivo Dockerfile de SparkR**

Las imágenes de Docker creadas a partir de este archivo Dockerfile incluyen R y el paquete randomForest CRAN. Este archivo Dockerfile incluye Amazon Linux 2 y 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')"
```

Para obtener más información sobre la sintaxis de los archivos Dockerfile, consulte la [documentación de referencia de Dockerfile](https://docs.docker.com/engine/reference/builder/).

## Uso de imágenes de Docker de Amazon ECR
<a name="emr-spark-docker-ECR"></a>

Amazon Elastic Container Registry (Amazon ECR) es un registro de contenedores de Docker completamente administrado que facilita el almacenamiento, la administración y la implementación de imágenes de contenedores de Docker. Cuando se utiliza Amazon ECR, el clúster debe configurarse de tal forma que confíe en su instancia de ECR. Además, debe configurar la autenticación para que el clúster utilice imágenes de Docker desde Amazon ECR. Para obtener más información, consulte [Configuración de YARN para acceder a Amazon ECR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html#emr-docker-ECR). 

Para garantizar que los hosts de Amazon EMR puedan acceder a las imágenes almacenadas en Amazon ECR, su clúster debe tener los permisos de la política `AmazonEC2ContainerRegistryReadOnly` asociados al perfil de instancia. Para obtener más información, consulte la política [https://docs.aws.amazon.com/AmazonECR/latest/userguide/ecr_managed_policies.html#AmazonEC2ContainerRegistryReadOnly](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ecr_managed_policies.html#AmazonEC2ContainerRegistryReadOnly).

En este ejemplo, el clúster debe crearse con la siguiente configuración adicional para asegurarse de que el registro de Amazon ECR sea de confianza. Sustituya el *123456789123.dkr.ecr.us-east-1.amazonaws.com* punto de conexión por su punto de conexión de Amazon ECR.

```
[
  {
    "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": {}
  }
]
```

**Uso PySpark con Amazon ECR**

El siguiente ejemplo usa el PySpark Dockerfile, que se etiquetará y se cargará en Amazon ECR. Tras cargar el Dockerfile, puede ejecutar el PySpark trabajo y consultar la imagen de Docker de Amazon ECR.

Tras lanzar el clúster, utilice SSH para conectarse a un nodo principal y ejecute los siguientes comandos para crear la imagen de Docker local a partir del ejemplo de Dockerfile. PySpark 

Primero, cree un directorio y un archivo Dockerfile.

```
mkdir pyspark
vi pyspark/Dockerfile
```

Pegue el contenido del PySpark Dockerfile y ejecute los siguientes comandos para crear una imagen de Docker.

```
sudo docker build -t local/pyspark-example pyspark/
```

Cree el repositorio `emr-docker-examples` de ECR para los ejemplos.

```
aws ecr create-repository --repository-name emr-docker-examples
```

Etiquete y cargue la imagen creada localmente en ECR y *123456789123.dkr.ecr.us-east-1.amazonaws.com* sustitúyala por su terminal de ECR.

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

Utilice SSH para conectarse al nodo principal y preparar un script de Python con el nombre de archivo `main.py`. Pegue el siguiente contenido en el archivo `main.py` y guárdelo.

```
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)
```

En Amazon EMR 6.0.0, para enviar el trabajo, haga referencia al nombre de la imagen de Docker. Defina los parámetros de configuración adicionales para asegurarse de que la ejecución del trabajo utiliza Docker como tiempo de ejecución. Cuando se utiliza Amazon ECR, `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` debe hacer referencia al archivo `config.json` que contiene las credenciales utilizadas para autenticarse en Amazon ECR.

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

En la versión 6.1.0 y posteriores de Amazon EMR, para enviar el trabajo, haga referencia al nombre de la imagen de Docker. Cuando la autenticación automática de ECR esté habilitada, ejecute el siguiente comando.

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

Cuando se complete el trabajo, anote el ID de la aplicación YARN y utilice el siguiente comando para obtener el resultado del PySpark trabajo.

```
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]]
```

**Uso de SparkR con Amazon ECR**

En el ejemplo siguiente se utiliza el archivo Dockerfile de SparkR, que se etiquetará y se cargará en ECR. Una vez cargado el Dockerfile, puede ejecutar el trabajo de SparkR y hacer referencia a la imagen de Docker desde Amazon ECR.

Después de iniciar el clúster, utilice SSH para conectarse a un nodo principal y ejecute los siguientes comandos para crear la imagen de Docker local desde el ejemplo de archivo Dockerfile de SparkR.

Primero, cree un directorio y el archivo Dockerfile.

```
mkdir sparkr
vi sparkr/Dockerfile
```

Pegue el contenido del archivo Dockerfile de SparkR y ejecute los siguientes comandos para crear una imagen de Docker.

```
sudo docker build -t local/sparkr-example sparkr/
```

Etiquete y cargue la imagen creada localmente en Amazon ECR y sustitúyala por su *123456789123.dkr.ecr.us-east-1.amazonaws.com* punto de conexión de Amazon ECR.

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

Utilice SSH para conectarse al nodo principal y preparar un script de R con el nombre `sparkR.R`. Pegue los siguientes contenidos en el archivo `sparkR.R`:

```
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()
```

En Amazon EMR 6.0.0, para enviar el trabajo, haga referencia al nombre de la imagen de Docker. Defina los parámetros de configuración adicionales para asegurarse de que la ejecución del trabajo utiliza Docker como tiempo de ejecución. Cuando se utiliza Amazon ECR, `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` debe hacer referencia al archivo `config.json` que contiene las credenciales utilizadas para autenticarse en ECR.

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

En la versión 6.1.0 y posteriores de Amazon EMR, para enviar el trabajo, haga referencia al nombre de la imagen de Docker. Cuando la autenticación automática de ECR esté habilitada, ejecute el siguiente comando.

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

Cuando el trabajo se haya completado, tome nota del ID de aplicación de YARN y utilice el siguiente comando para obtener la salida del trabajo de SparkR. Este ejemplo incluye pruebas para asegurarse de que la biblioteca randomForest, la versión instalada y las notas de la versión están disponibles.

```
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:
```