Consideraciones Creación de una imagen de Docker Uso de imágenes de Docker de Amazon ECR

Ejecución de aplicaciones de Spark con Docker en Amazon EMR 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.

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

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_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG={DOCKER_CLIENT_CONFIG_PATH_ON_HDFS}
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.

Creación de una imagen de Docker

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.

Uso de imágenes de Docker de Amazon ECR

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.

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 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 punto de conexión 123456789123.dkr.ecr.us-east-1.amazonaws.com su propio 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, pero sustituya 123456789123.dkr.ecr.us-east-1.amazonaws.com por su propio punto de enlace 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 trabajo. PySpark


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, pero sustituya 123456789123.dkr.ecr.us-east-1.amazonaws.com por su propio 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()


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


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:

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Creación de un clúster de Spark

Usa el catálogo de datos de AWS Glue como metaalmacén para Spark SQL