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á.

# Execução de aplicações do Spark com o Docker no Amazon EMR 6.x
<a name="emr-spark-docker"></a>

**nota**  
O procedimento descrito funciona somente com o Amazon EMR versão 6.x.

Com o Amazon EMR 6.0.0, as aplicações do Spark podem usar contêineres do Docker para definir suas dependências de biblioteca, em vez de instalar dependências nas instâncias individuais do 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](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).

Quando o aplicativo é enviado, o YARN invoca o Docker para extrair a imagem especificada do Docker 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 bootstrapping ou de preparação de instâncias no cluster do Amazon EMR com as bibliotecas necessárias para a execução do trabalho. 

## Considerações ao executar o Spark com o Docker
<a name="emr-spark-docker-considerations"></a>

Ao executar o Spark com o Docker, verifique se os seguintes pré-requisitos são atendidos:
+ O pacote `docker` e a CLI são instalados somente nos nós core e de tarefa.
+ Nas versões 6.1.0 r posteriores do Amazon EMR, você pode, como alternativa, instalar o Docker em um nó primário usando os comandos a seguir.
  + 

    ```
    sudo yum install -y docker
    sudo systemctl start docker
    ```
+ O comando `spark-submit` sempre deve ser executado em uma instância primária no cluster do Amazon EMR.
+ Os registros do Docker usados para resolver imagens do Docker devem ser definidos usando a API de classificação com a chave de classificação `container-executor` para definir parâmetros adicionais ao executar 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 o Amazon ECR para recuperar imagens do Docker, é necessário configurar o cluster para ele se autenticar. Para fazer isso, é necessário usar a seguinte opção de configuração:
  + YARN\$1CONTAINER\$1RUNTIME\$1DOCKER\$1CLIENT\$1CONFIG=\$1DOCKER\$1CLIENT\$1CONFIG\$1PATH\$1ON\$1HDFS\$1
+ Nas versões 6.1.0 e posteriores do Amazon EMR, 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 automático do ECR está habilitado.
+ 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](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).

## Criar uma imagem do Docker
<a name="emr-spark-docker-image"></a>

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 Dockerfile**

As imagens do Docker criadas a partir desse Dockerfile incluem o Python 3 e o pacote Python. NumPy Esse arquivo do Docker usa o Amazon Linux 2 e o 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"
```

**Arquivo do Docker do SparkR**

As imagens do Docker criadas com esse arquivo do Docker incluem R e o pacote randomForest CRAN. Esse arquivo do Docker inclui o Amazon Linux 2 e o 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 obter mais informações sobre a sintaxe do arquivo do Docker, consulte a [documentação de referência do arquivo do Docker](https://docs.docker.com/engine/reference/builder/).

## Usar imagens do Docker do Amazon ECR
<a name="emr-spark-docker-ECR"></a>

O Amazon Elastic Container Registry (Amazon ECR) é um registro de contêiner do Docker totalmente gerenciado que facilita o armazenamento, o gerenciamento e a implantação de imagens de contêiner do Docker. Ao ser usado o Amazon ECR, o cluster deve ser configurado para confiar na instância do ECR e você deve configurar a autenticação para que o cluster use imagens do Docker do Amazon ECR. Para obter mais informações, consulte [Configurar o YARN para acessar o Amazon ECR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html#emr-docker-ECR). 

Para garantir que os hosts do Amazon EMR possam acessar as imagens armazenadas no Amazon ECR, o cluster deve ter as permissões da política `AmazonEC2ContainerRegistryReadOnly` associada ao perfil de instância. Para obter mais informações, consulte [Política `AmazonEC2ContainerRegistryReadOnly`](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ecr_managed_policies.html#AmazonEC2ContainerRegistryReadOnly).

Nesse exemplo, o cluster deve ser criado com a configuração adicional a seguir para garantir que o registro do Amazon ECR seja confiável. Substitua o *123456789123.dkr.ecr.us-east-1.amazonaws.com* endpoint pelo seu 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": {}
  }
]
```

**Usando PySpark com o Amazon ECR**

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

Depois de iniciar o cluster, use o SSH para se conectar a um nó principal e execute 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 repositório `emr-docker-examples` do ECR para os exemplos.

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

Marque e carregue a imagem criada localmente no ECR, substituindo-a por seu *123456789123.dkr.ecr.us-east-1.amazonaws.com* endpoint 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
```

Use SSH para se conectar ao nó primário e prepare um script do Python com o nome de 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)
```

No 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 ser usado o Amazon ECR, o `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` deve fazer referência ao arquivo `config.json` contendo as credenciais usadas para fazer a autenticação no 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
```

Nas versões 6.1.0 e superiores do Amazon EMR, para enviar o trabalho, consulte o nome da imagem do Docker. Quando a autenticação automática do ECR 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 aplicativo YARN 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]]
```

**Usar o SparkR com o Amazon ECR**

O exemplo a seguir usa o arquivo do Docker do SparkR, que será marcado e carregado no ECR. Depois de carregar o Dockerfile, você pode executar o trabalho do SparkR e consultar a imagem do Docker no Amazon ECR.

Após executar o cluster, use o SSH para se conectar a um nó core e execute os comandos a seguir a fim de criar a imagem local do Docker com base no exemplo de arquivo do Docker do SparkR.

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 o Amazon ECR, *123456789123.dkr.ecr.us-east-1.amazonaws.com* substituindo-a por seu 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
```

Use SSH para se conectar ao nó primário e prepare um script R com o nome `sparkR.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()
```

No 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 ser usado o Amazon ECR, o `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` deve fazer referência ao arquivo `config.json` contendo as credenciais usadas para fazer a autenticação no 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
```

Nas versões 6.1.0 e superiores do Amazon EMR, para enviar o trabalho, consulte o nome da imagem do Docker. Quando a autenticação automática do ECR estiver habilitada, execute o comando a seguir.

```
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 aplicativo YARN e use o comando a seguir para obter a saída do trabalho do SparkR. Esse exemplo inclui testes para garantir que a biblioteca randomForest, a versão instalada e as notas de release 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:
```