Execute aplicativos Spark com o Docker na Amazon 6.x EMR - Amazon EMR
ConsideraçõesCriar uma imagem do DockerUsando imagens Docker da Amazon ECR

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Execute aplicativos Spark com o Docker na Amazon 6.x EMR

Com o Amazon EMR 6.0.0, os aplicativos Spark podem usar contêineres Docker para definir suas dependências de biblioteca, em vez de instalar dependências nas instâncias individuais da Amazon EC2 no cluster. Para executar o Spark com o Docker, primeiro é necessário configurar o registro do Docker e definir parâmetros adicionais ao enviar um aplicativo do Spark. Para obter mais informações, consulte Configurar a integração do Docker.

Quando o aplicativo é enviado, YARN invoca o Docker para extrair a imagem do Docker especificada e executar o aplicativo Spark dentro de um contêiner do Docker. Isso permite definir e isolar dependências facilmente. Isso reduz o tempo de inicialização ou preparação de instâncias no EMR cluster da Amazon com as bibliotecas necessárias para a execução do trabalho.

Considerações ao executar o Spark com o Docker

Ao executar o Spark com o Docker, verifique se os seguintes pré-requisitos são atendidos:

  • O docker pacote e CLI são instalados somente nos nós principais e de tarefas.

  • No Amazon EMR 6.1.0 e versões posteriores, você também pode instalar o Docker em um nó primário usando os seguintes comandos.

    • sudo yum install -y docker
sudo systemctl start docker

  • O spark-submit comando sempre deve ser executado a partir de uma instância primária no EMR cluster da Amazon.

  • Os registros do Docker usados para resolver imagens do Docker devem ser definidos usando a Classificação API com a chave de container-executor classificação para definir parâmetros adicionais ao iniciar o cluster:

    • docker.trusted.registries

    • docker.privileged-containers.registries

  • Para executar um aplicativo do Spark em um contêiner do Docker, as seguintes opções de configuração são necessárias:

    • YARN_CONTAINER_RUNTIME_TYPE=docker

    • YARN_CONTAINER_RUNTIME_DOCKER_IMAGE={DOCKER_IMAGE_NAME}

  • Ao usar ECR a Amazon para recuperar imagens do Docker, você deve configurar o cluster para se autenticar. Para fazer isso, é necessário usar a seguinte opção de configuração:

    • YARN_ CONTAINER _ RUNTIME _ _ DOCKER CLIENT _ CONFIG = {DOCKER_ _ CLIENT _ CONFIG PATH HDFS _EM_}

  • No Amazon EMR 6.1.0 e versões posteriores, você não precisa usar o comando listado YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG={DOCKER_CLIENT_CONFIG_PATH_ON_HDFS} quando o recurso de autenticação ECR automática está ativado.

  • Qualquer imagem do Docker usada com o Spark deve ter o Java instalado na imagem do Docker.

Para obter mais informações sobre os pré-requisitos, consulte Configurar a integração do Docker.

Criar uma imagem do Docker

As imagens do Docker são criadas usando um arquivo do Docker, que define os pacotes e a configuração a serem incluídos na imagem. Os dois exemplos a seguir são usados por Dockerfiles e PySpark SparkR.

PySpark Arquivo Docker

As imagens do Docker criadas a partir desse Dockerfile incluem o Python 3 e o pacote Python. NumPy Esse Dockerfile usa o Amazon Linux 2 e o Amazon Corretto 8. JDK

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"

Arquivo do Docker do SparkR

As imagens do Docker criadas a partir desse Dockerfile incluem R e o pacote. randomForest CRAN Esse Dockerfile inclui o Amazon Linux 2 e o Amazon Corretto 8. JDK

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 obter mais informações sobre a sintaxe do arquivo do Docker, consulte a documentação de referência do arquivo do Docker.

Usando imagens Docker da Amazon ECR

O Amazon Elastic Container Registry (AmazonECR) é um registro de contêineres do Docker totalmente gerenciado, que facilita o armazenamento, o gerenciamento e a implantação de imagens de contêineres do Docker. Ao usar a AmazonECR, o cluster deve ser configurado para confiar na sua instância doECR, e você deve configurar a autenticação para que o cluster use imagens Docker da AmazonECR. Para obter mais informações, consulte Configuração YARN para acessar a Amazon ECR.

Para garantir que EMR os hosts da Amazon possam acessar as imagens armazenadas na AmazonECR, seu cluster deve ter as permissões da AmazonEC2ContainerRegistryReadOnly política associada ao perfil da instância. Para obter mais informações, consulte Política AmazonEC2ContainerRegistryReadOnly.

Neste exemplo, o cluster deve ser criado com a seguinte configuração adicional para garantir que o ECR registro da Amazon seja confiável. Substitua o 123456789123.dkr.ecr.us-east-1.amazonaws.com endpoint com seu ECR endpoint da Amazon.

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

Usando PySpark com a Amazon ECR

O exemplo a seguir usa o PySpark Dockerfile, que será marcado e enviado para a Amazon. ECR Depois de fazer o upload do Dockerfile, você pode executar o PySpark trabalho e consultar a imagem do Docker da Amazon. ECR

Depois de iniciar o cluster, use SSH para se conectar a um nó principal e executar os comandos a seguir para criar a imagem local do Docker a partir do exemplo do PySpark Dockerfile.

Primeiro, crie um diretório e um arquivo do Docker.

mkdir pyspark
vi pyspark/Dockerfile

Cole o conteúdo do PySpark Dockerfile e execute os comandos a seguir para criar uma imagem do Docker.

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

Crie o emr-docker-examples ECR repositório para os exemplos.

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

Marque e faça o upload da imagem criada localmente paraECR, substituindo 123456789123.dkr.ecr.us-east-1.amazonaws.com com seu ECR endpoint.

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

Use SSH para se conectar ao nó primário e preparar um script Python com o nome do arquivo. main.py Cole o conteúdo a seguir no arquivo main.py e salve-o.

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)

Na Amazon EMR 6.0.0, para enviar o trabalho, faça referência ao nome da imagem do Docker. Defina os parâmetros de configuração adicionais para garantir que a execução do trabalho use o Docker como o runtime. Ao usar a AmazonECR, é YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG necessário referenciar o config.json arquivo contendo as credenciais usadas para se autenticar na 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

No Amazon EMR 6.1.0 e versões posteriores, para enviar o trabalho, faça referência ao nome da imagem do Docker. Quando a autenticação ECR automática estiver habilitada, execute o comando a seguir.

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

Quando o trabalho for concluído, anote o ID do YARN aplicativo e use o comando a seguir para obter a saída do PySpark trabalho.

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

Usando o SparkR com a Amazon ECR

O exemplo a seguir usa o SparkR Dockerfile, que será marcado e enviado para. ECR Depois que o Dockerfile for carregado, você poderá executar o trabalho SparkR e consultar a imagem do Docker da Amazon. ECR

Depois de iniciar o cluster, use SSH para se conectar a um nó principal e executar os comandos a seguir para criar a imagem local do Docker a partir do exemplo do SparkR Dockerfile.

Primeiro, crie um diretório e o arquivo do Docker.

mkdir sparkr
vi sparkr/Dockerfile

Cole os conteúdos do arquivo do Docker do SparkR e execute os comandos a seguir para criar uma imagem do Docker.

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

Marque e faça o upload da imagem criada localmente para a AmazonECR, substituindo 123456789123.dkr.ecr.us-east-1.amazonaws.com com seu ECR endpoint da Amazon.

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

Use SSH para se conectar ao nó primário e preparar um script R com o nomesparkR.R. Cole o conteúdo a seguir no arquivo 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()

Na Amazon EMR 6.0.0, para enviar o trabalho, consulte o nome da imagem do Docker. Defina os parâmetros de configuração adicionais para garantir que a execução do trabalho use o Docker como o runtime. Ao usar a AmazonECR, eles YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG devem se referir ao config.json arquivo que contém as credenciais usadas para se autenticar. 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

No Amazon EMR 6.1.0 e versões posteriores, para enviar o trabalho, faça referência ao nome da imagem do Docker. Quando a autenticação ECR automática estiver habilitada, execute o seguinte 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

Quando o trabalho for concluído, anote o ID do YARN aplicativo e use o comando a seguir para obter a saída do trabalho SparkR. Esse exemplo inclui testes para garantir que a randomForest biblioteca, a versão instalada e as notas de lançamento estejam disponíveis.

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: