Considerazioni Creazione di un'immagine Docker Utilizzo delle immagini Docker da Amazon ECR

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, bisogna 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 Amazon 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 due esempi seguenti utilizzano Dockerfiles e PySpark SparkR.

PySpark Dockerfile

Le immagini Docker create da questo Dockerfile includono Python 3 e il pacchetto Python. NumPy 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 Amazon 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 PySpark con Amazon ECR

L'esempio seguente utilizza il PySpark Dockerfile, che verrà taggato e caricato su Amazon ECR. Dopo aver caricato il Dockerfile, puoi eseguire il PySpark job e fare riferimento all'immagine Docker da Amazon ECR.

Dopo aver avviato il cluster, usa SSH per connetterti a un nodo principale ed esegui i seguenti comandi per creare l'immagine Docker locale dall'esempio di Dockerfile. PySpark

Innanzitutto, crea una directory e un Dockerfile.


mkdir pyspark
vi pyspark/Dockerfile

Incolla il contenuto del PySpark Dockerfile ed esegui 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 Amazon 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 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 Amazon 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 lavoro, prendi nota dell'ID dell'applicazione YARN e usa il seguente comando per ottenere l'output del lavoro. 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()


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

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:

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Creazione di un cluster con Spark

Usa il AWS Glue Data Catalog come metastore per Spark SQL