Esecuzione di applicazioni Spark con Docker utilizzando Amazon EMR 6.x - Amazon EMR

Esecuzione di applicazioni Spark con Docker utilizzando Amazon EMR 6.x

Con Amazon EMR 6.0.0, le applicazioni Spark possono utilizzare i container Docker per definire le dipendenze delle librerie anziché installare le dipendenze sulle singole istanze Amazon EC2 del cluster. Per eseguire Spark con Docker, è necessario innanzitutto configurare il Registro di sistema Docker e definire parametri aggiuntivi quando si invia un'applicazione Spark. Per ulteriori informazioni, consulta Configurazione dell'integrazione di Docker.

Quando l'applicazione viene inviata, YARN richiama Docker per estrarre l'immagine Docker specificata ed eseguire l'applicazione Spark all'interno di un container Docker. Ciò consente di definire e isolare facilmente le dipendenze. Riduce il tempo per il processo di bootstrap o la preparazione delle istanze nel cluster Amazon EMR con le librerie necessarie per l'esecuzione del processo.

Considerazioni sull'esecuzione di Spark con Docker

Quando si esegue Spark con Docker, assicurarsi che siano soddisfatti i seguenti prerequisiti:

  • Il pacchetto docker e l'interfaccia della CLI sono installati solo sui nodi core e task.

  • In alternativa, su Amazon EMR rilascio 6.1.0 e successivi è possibile installare Docker su un nodo primario utilizzando i seguenti comandi.

    • sudo yum install -y docker sudo systemctl start docker
  • Il comando spark-submit deve sempre essere eseguito da un'istanza primaria nel cluster Amazon EMR.

  • I registri Docker utilizzati per risolvere le immagini Docker devono essere definiti utilizzando l'API di classificazione con la chiave di classificazione container-executor per definire parametri aggiuntivi all'avvio del cluster:

    • docker.trusted.registries

    • docker.privileged-containers.registries

  • Per eseguire un'applicazione Spark in un container Docker, sono necessarie le seguenti opzioni di configurazione:

    • YARN_CONTAINER_RUNTIME_TYPE=docker

    • YARN_CONTAINER_RUNTIME_DOCKER_IMAGE={DOCKER_IMAGE_NAME}

  • Quando si utilizza Amazon ECR per recuperare le immagini Docker, è necessario configurare il cluster per autenticarsi. A tale scopo, è necessario utilizzare la seguente opzione di configurazione:

    • YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG={DOCKER_CLIENT_CONFIG_PATH_ON_HDFS}

  • In EMR 6.1.0 e versioni successive non è necessario utilizzare il comando elencato YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG={DOCKER_CLIENT_CONFIG_PATH_ON_HDFS} quando è abilitata la funzionalità di autenticazione automatica ECR.

  • Qualsiasi immagine Docker utilizzata con Spark deve avere Java installato nell'immagine Docker.

Per ulteriori informazioni sui prerequisiti, consulta Configurazione dell'integrazione di Docker.

Creazione di un'immagine Docker

Le immagini Docker vengono create utilizzando un Dockerfile, che definisce i pacchetti e la configurazione da includere nell'immagine. I seguenti due Dockerfiles di esempio utilizzano PySpark e SparkR.

Dockerfile di PySpark

Le immagini Docker create da questo Dockerfile includono Python 3 e il pacchetto NumPy Python. Questo Dockerfile utilizza Amazon Linux 2 e 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"

Dockerfile SparkR

Le immagini Docker create da questo Dockerfile includono R e il pacchetto RandomForest CRAN. Questo Dockerfile include Amazon Linux 2 e 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')"

Per ulteriori informazioni sulla sintassi Dockerfile, vedere la documentazione di riferimento Dockerfile.

Utilizzo delle immagini Docker da Amazon ECR

Amazon Elastic Container Registry (Amazon ECR) è un registro completamente gestito del container Docker che permette agli sviluppatori di archiviare, gestire e distribuire in modo semplice le immagini dei container Docker. Durante l'utilizzo di Amazon ECR, il cluster deve essere configurato in modo da considerare attendibile l'istanza di ECR ed è necessario configurare l'autenticazione affinché il cluster possa utilizzare le immagini Docker da Amazon ECR. Per ulteriori informazioni, consulta Configurazione di YARN per accedere ad Amazon ECR.

Per assicurarsi che gli host EMR possano accedere alle immagini archiviate in Amazon ECR, il cluster deve disporre delle autorizzazioni dalla policy AmazonEC2ContainerRegistryReadOnly associata al profilo dell'istanza. Per maggiori informazioni, consulta Policy AmazonEC2ContainerRegistryReadOnly.

In questo esempio, il cluster deve essere creato con la seguente configurazione aggiuntiva per garantire che il registro Amazon ECR sia attendibile. Sostituisci l'endpoint 123456789123.dkr.ecr.us-east-1.amazonaws.com con l'endpoint 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": {} } ]

Utilizzo di PySpark con Amazon ECR

Nell'esempio seguente viene utilizzato il file Dockerfile PySpark, che verrà taggato e caricato su Amazon ECR. Dopo il caricamento del Dockerfile, è possibile eseguire il processo PySpark e fare riferimento all'immagine Docker da Amazon ECR.

Dopo aver avviato il cluster, utilizzare SSH per connettersi a un nodo principale ed eseguire i comandi seguenti per creare l'immagine Docker locale dal Dockerfile PySpark di esempio.

Innanzitutto, crea una directory e un Dockerfile.

mkdir pyspark vi pyspark/Dockerfile

Incollare il contenuto del Dockerfile PySpark ed eseguire i seguenti comandi per creare un'immagine Docker.

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

Creare il repository emr-docker-examples ECR per gli esempi.

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

Etichetta e carica l'immagine creata localmente in ECR, sostituendo 123456789123.dkr.ecr.us-east-1.amazonaws.com con l'endpoint 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

Utilizza SSH per connetterti al nodo primario e preparare uno script Python con il nome del file main.py. Incolla il seguente contenuto nel file main.py e salvalo.

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)

Per inviare il processo su EMR 6.0.0, fare riferimento al nome dell'immagine Docker. Definire i parametri di configurazione aggiuntivi per assicurarsi che l'esecuzione del processo utilizzi Docker come runtime. Durante l'utilizzo di Amazon ECR, YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG deve fare riferimento al file config.json contenente le credenziali utilizzate per l'autenticazione ad 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

Per inviare il processo su EMR 6.1.0 e versioni successive, fai riferimento al nome dell'immagine Docker. Quando è attivata l'autenticazione automatica ECR, esegui il comando riportato di seguito.

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

Al termine del processo, prendere nota dell'ID applicazione YARN e utilizzare il comando seguente per ottenere l'output del processo 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]]

Utilizzo di SparkR con Amazon ECR

Nell'esempio seguente viene utilizzato il Dockerfile SparkR, che verrà taggato e caricato in ECR. Una volta caricato il Dockerfile, è possibile eseguire il processo SparkR e fare riferimento all'immagine Docker da Amazon ECR.

Dopo aver avviato il cluster, utilizzare SSH per connettersi a un nodo principale ed eseguire i comandi seguenti per creare l'immagine Docker locale dall'esempio Dockerfile SparkR.

Innanzitutto, creare una directory e il Dockerfile.

mkdir sparkr vi sparkr/Dockerfile

Incollare il contenuto del Dockerfile SparkR ed eseguire i seguenti comandi per creare un'immagine Docker.

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

Etichetta e carica l'immagine creata localmente in Amazon ECR, sostituendo 123456789123.dkr.ecr.us-east-1.amazonaws.com con l'endpoint 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

Utilizza SSH per connetterti al nodo primario e preparare uno script R con il nome sparkR.R. Incollare i contenuti seguenti nel file 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()

Per inviare il processo su EMR 6.0.0, fai riferimento al nome dell'immagine Docker. Definire i parametri di configurazione aggiuntivi per assicurarsi che l'esecuzione del processo utilizzi Docker come runtime. Durante l'utilizzo di Amazon ECR, YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG deve fare riferimento al file config.json contenente le credenziali utilizzate per l'autenticazione a 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

Per inviare il processo su EMR 6.1.0 e versioni successive, fai riferimento al nome dell'immagine Docker. Quando è attivata l'autenticazione automatica ECR, esegui il comando riportato di seguito.

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

Una volta completato il processo, prendere nota dell'ID applicazione YARN e utilizzare il comando seguente per ottenere l'output del processo SparkR. Questo esempio include test per assicurarsi che la libreria RandomForest, la versione installata e le note sulla versione siano disponibili.

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: