Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Esecuzione di applicazioni Spark con Docker utilizzando Amazon EMR 6.x
<a name="emr-spark-docker"></a>

**Nota**  
La procedura descritta funziona solo con Amazon EMR versione 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](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).

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
<a name="emr-spark-docker-considerations"></a>

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](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).

## Creazione di un'immagine Docker
<a name="emr-spark-docker-image"></a>

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](https://docs.docker.com/engine/reference/builder/).

## Utilizzo delle immagini Docker da Amazon ECR
<a name="emr-spark-docker-ECR"></a>

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](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html#emr-docker-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`](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ecr_managed_policies.html#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'{{123456789123.dkr.ecr.us-east-1.amazonaws.com}}endpoint con il tuo 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 su ECR, sostituendola {{123456789123.dkr.ecr.us-east-1.amazonaws.com}} con il tuo 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 su Amazon ECR, sostituendola {{123456789123.dkr.ecr.us-east-1.amazonaws.com}} con il tuo 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 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 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 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: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:
```