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

# Apache Spark
<a name="emr-spark"></a>

[Apache Spark](https://aws.amazon.com/emr/features/spark/) è un framework di elaborazione distribuito e un modello di programmazione che consente di eseguire attività come machine learning, elaborazione di flussi o analisi di grafici con i cluster Amazon EMR. Come Apache Hadoop, Spark è un sistema di elaborazione distribuito open source utilizzato in genere per carichi di lavoro di Big Data. Tuttavia, Spark presenta diverse differenze notevoli rispetto a Hadoop. MapReduce in quanto dispone di un motore di esecuzione di grafi aciclici orientati (DAG) ottimizzato e memorizza attivamente i dati nella cache. Queste caratteristiche possono migliorare le prestazioni, in particolare per determinati algoritmi e query interattive.

Spark supporta applicazioni scritte in Scala, Python e Java a livello nativo. [Include anche diverse librerie strettamente integrate per SQL ([Spark](https://spark.apache.org/sql/)), machine learning ([MLlib](https://spark.apache.org/mllib/)), stream processing ([Spark streaming](https://spark.apache.org/streaming/)) ed elaborazione di grafici (GraphX).](https://spark.apache.org/graphx/) Questi strumenti semplificano l'utilizzo del framework Spark per un'ampia gamma di casi d'uso. 

Puoi installare Spark su un cluster Amazon EMR insieme ad altre applicazioni Hadoop. Questa soluzione consente inoltre l'utilizzo del file system Amazon EMR (EMRFS) per accedere direttamente ai dati in Amazon S3. Hive è anche integrato con Spark in modo da poter utilizzare un HiveContext oggetto per eseguire gli script Hive utilizzando Spark. Un contesto Hive è incluso nella shell di Spark come `sqlContext`. 

Per un esempio di tutorial sulla configurazione di un cluster EMR con Spark e l'analisi di un set di dati di esempio, consulta [Tutorial: Getting started with Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html) sul blog News. AWS 

Puoi utilizzare Apache Spark Troubleshooting Agent per risolvere i problemi delle tue applicazioni Apache Spark su EMR su EC2 ed EMR Serverless. [Cos'è l'agente di risoluzione dei problemi di Apache Spark per Amazon EMR?](spark-troubleshoot.md)Per saperne di più, consulta.

**Importante**  
Apache Spark versione 2.3.1, disponibile a partire da Amazon EMR rilascio 5.16.0, risolve [CVE-2018-8024](https://nvd.nist.gov/vuln/detail/CVE-2018-8024) e [CVE-2018-1334](https://nvd.nist.gov/vuln/detail/CVE-2018-1334). Si consiglia di eseguire la migrazione delle versioni precedenti di Spark a Spark 2.3.1 o versioni successive.

La seguente tabella indica la versione di Spark inclusa nell'ultimo rilascio della serie Amazon EMR 7.x insieme ai componenti che Amazon EMR installa con Spark.

Per la versione dei componenti installati con Spark in questa versione, consulta Versioni dei componenti della [release 7.12.0](emr-7120-release.md).


**Informazioni sulla versione di Spark per emr-7.12.0**  

| Etichetta di rilascio di Amazon EMR | Versione di Spark | Componenti installati con Spark | 
| --- | --- | --- | 
| emr-7.12.0 | Spark 3.5.6-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 

La seguente tabella indica la versione di Spark inclusa nell'ultimo rilascio della serie Amazon EMR 6.x insieme ai componenti che Amazon EMR installa con Spark.

Per la versione dei componenti installati con Spark in questo rilascio, consulta la sezione [Versioni dei componenti del rilascio 6.15.0](emr-6150-release.md).


**Informazioni sulla versione di Spark per emr-6.15.0**  

| Etichetta di rilascio di Amazon EMR | Versione di Spark | Componenti installati con Spark | 
| --- | --- | --- | 
| emr-6.15.0 | Spark 3.4.1-amzn-2 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 

**Nota**  
Rilascio 6.8.0 di Amazon EMR con Spark per Apache 3.3.0. Questa versione di Spark utilizza Apache Log4j 2 e il file `log4j2.properties` per configurare Log4j nei processi Spark. Se utilizzi Spark nel cluster o crei cluster EMR con parametri di configurazione personalizzati e desideri eseguire l'aggiornamento alla versione 6.8.0 di Amazon EMR, devi migrare alla nuova classificazione della configurazione e formato chiave `spark-log4j2` per Apache Log4j 2. Per ulteriori informazioni, consulta [Migrazione da Apache Log4j 1.x a Log4j 2.x](emr-spark-configure.md#spark-migrate-logj42).

La seguente tabella indica la versione di Spark inclusa nell'ultimo rilascio della serie Amazon EMR 5.x insieme ai componenti che Amazon EMR installa con Spark.

[Per la versione dei componenti installati con Spark in questa versione, vedi Versioni dei componenti della release 5.36.2.](emr-5362-release.md)


**Informazioni sulla versione di Spark per emr-5.36.2**  

| Etichetta di rilascio di Amazon EMR | Versione di Spark | Componenti installati con Spark | 
| --- | --- | --- | 
| emr-5.36.2 | Spark 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 

**Topics**
+ [Creazione di un cluster con Apache Spark](emr-spark-launch.md)
+ [Esecuzione di applicazioni Spark con Docker utilizzando Amazon EMR 6.x](emr-spark-docker.md)
+ [Usa il catalogo AWS Glue Data Catalog con Spark su Amazon EMR](emr-spark-glue.md)
+ [Utilizzo di una gerarchia multicatalogo in AWS Glue Data Catalog with Spark su Amazon EMR](emr-multi-catalog.md)
+ [Configurazione di Spark](emr-spark-configure.md)
+ [Cos'è l'agente di risoluzione dei problemi di Apache Spark per Amazon EMR?](spark-troubleshoot.md)
+ [Ottimizzazione delle prestazioni di Spark](emr-spark-performance.md)
+ [Caching dei frammenti dei risultati Spark](emr-spark-fragment-result-caching.md)
+ [Utilizza Nvidia RAPIDS Accelerator per Apache Spark](emr-spark-rapids.md)
+ [Accesso alla shell Spark](emr-spark-shell.md)
+ [Usa Amazon SageMaker Spark per l'apprendimento automatico](emr-spark-sagemaker.md)
+ [Scrittura di un'applicazione Spark](emr-spark-application.md)
+ [Migliorare le prestazioni di Spark con Amazon S3](emr-spark-s3-performance.md)
+ [Aggiungi una fase Spark](emr-spark-submit-step.md)
+ [Visualizzazione della cronologia delle applicazioni Spark](emr-spark-application-history.md)
+ [Accedi al sito web Spark UIs](emr-spark-webui.md)
+ [Utilizzo del connettore Amazon Kinesis Data Streams per lo streaming strutturato Spark](emr-spark-structured-streaming-kinesis.md)
+ [Utilizzo dell'integrazione di Amazon Redshift per Apache Spark su Amazon EMR](emr-spark-redshift.md)
+ [Cronologia dei rilasci di Spark](Spark-release-history.md)
+ [Utilizzo di viste materializzate con Amazon EMR](emr-spark-materialized-views.md)

# Creazione di un cluster con Apache Spark
<a name="emr-spark-launch"></a>

La procedura seguente consente di creare un cluster con [Spark](https://aws.amazon.com/big-data/what-is-spark/) installato utilizzando **Opzioni rapide** nella console di Amazon EMR.

In alternativa, puoi utilizzare **Advanced Options (Opzioni avanzate)** per personalizzare ulteriormente la configurazione del cluster o per inviare fasi al fine di installare applicazioni a livello di codice e quindi eseguire le applicazioni personalizzate. Con una di queste opzioni di creazione del cluster, puoi scegliere di utilizzare AWS Glue come metastore Spark SQL. Per ulteriori informazioni, consulta [Usa il catalogo AWS Glue Data Catalog con Spark su Amazon EMR](emr-spark-glue.md).

**Per avviare un cluster con Spark installato**

1. [Apri la console Amazon EMR in /emr. https://console.aws.amazon.com](https://console.aws.amazon.com/emr/)

1. Scegli **Create cluster (Crea cluster)** per utilizzare **Quick Options (Opzioni rapide)**.

1. Immetti un **Cluster name (Nome cluster)**. Il nome del cluster non può contenere i caratteri <, >, \$1, \$1 o `(backtick).

1.  Per **Software Configuration (Configurazione del software)**, scegli un'opzione di **Release (Rilascio)**.

1.  Per **Applications (Applicazioni)**, scegli il bundle di applicazioni **Spark**.

1.  Seleziona le altre opzioni come richiesto, quindi scegli **Create cluster (Crea cluster)**.
**Nota**  
Per configurare Spark durante la creazione del cluster, consulta [Configurazione di Spark](emr-spark-configure.md).

**Per avviare un cluster con Spark installato utilizzando AWS CLI**
+ Creare il cluster con il seguente comando:

  ```
  aws emr create-cluster --name "Spark cluster" --release-label emr-7.12.0 --applications Name=Spark \
  --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 --use-default-roles
  ```

**Nota**  
I caratteri di continuazione della riga Linux (\$1) sono inclusi per la leggibilità. Possono essere rimossi o utilizzati nei comandi Linux. Per Windows, rimuoverli o sostituirli con un accento circonflesso (^).

**Avvio di un cluster con Spark installato mediante il kit SDK per Java**

Specificare Spark come applicazione con `SupportedProductConfig` utilizzato in `RunJobFlowRequest`.
+ L'esempio seguente mostra come creare un cluster con Spark utilizzando Java.

  ```
  import com.amazonaws.AmazonClientException;
  import com.amazonaws.auth.AWSCredentials;
  import com.amazonaws.auth.AWSStaticCredentialsProvider;
  import com.amazonaws.auth.profile.ProfileCredentialsProvider;
  import com.amazonaws.services.elasticmapreduce.AmazonElasticMapReduce;
  import com.amazonaws.services.elasticmapreduce.AmazonElasticMapReduceClientBuilder;
  import com.amazonaws.services.elasticmapreduce.model.*;
  import com.amazonaws.services.elasticmapreduce.util.StepFactory;
  
  public class Main {
  
          public static void main(String[] args) {
                  AWSCredentials credentials_profile = null;
                  try {
                          credentials_profile = new ProfileCredentialsProvider("default").getCredentials();
                  } catch (Exception e) {
                          throw new AmazonClientException(
                                          "Cannot load credentials from .aws/credentials file. " +
                                                          "Make sure that the credentials file exists and the profile name is specified within it.",
                                          e);
                  }
  
                  AmazonElasticMapReduce emr = AmazonElasticMapReduceClientBuilder.standard()
                                  .withCredentials(new AWSStaticCredentialsProvider(credentials_profile))
                                  .withRegion(Regions.US_WEST_1)
                                  .build();
  
                  // create a step to enable debugging in the AWS Management Console
                  StepFactory stepFactory = new StepFactory();
                  StepConfig enabledebugging = new StepConfig()
                                  .withName("Enable debugging")
                                  .withActionOnFailure("TERMINATE_JOB_FLOW")
                                  .withHadoopJarStep(stepFactory.newEnableDebuggingStep());
  
                  Application spark = new Application().withName("Spark");
  
                  RunJobFlowRequest request = new RunJobFlowRequest()
                                  .withName("Spark Cluster")
                                  .withReleaseLabel("emr-5.20.0")
                                  .withSteps(enabledebugging)
                                  .withApplications(spark)
                                  .withLogUri("s3://path/to/my/logs/")
                                  .withServiceRole("EMR_DefaultRole")
                                  .withJobFlowRole("EMR_EC2_DefaultRole")
                                  .withInstances(new JobFlowInstancesConfig()
                                                  .withEc2SubnetId("subnet-12ab3c45")
                                                  .withEc2KeyName("myEc2Key")
                                                  .withInstanceCount(3)
                                                  .withKeepJobFlowAliveWhenNoSteps(true)
                                                  .withMasterInstanceType("m4.large")
                                                  .withSlaveInstanceType("m4.large"));
                  RunJobFlowResult result = emr.runJobFlow(request);
                  System.out.println("The cluster ID is " + result.toString());
          }
  }
  ```

# 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\$1CONTAINER\$1RUNTIME\$1DOCKER\$1CLIENT\$1CONFIG=\$1DOCKER\$1CLIENT\$1CONFIG\$1PATH\$1ON\$1HDFS\$1
+ 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:
```

# Usa il catalogo AWS Glue Data Catalog con Spark su Amazon EMR
<a name="emr-spark-glue"></a>

Utilizzando Amazon EMR versione 5.8.0 o successiva, puoi configurare Spark per utilizzare AWS Glue Data Catalog come metastore Apache Hive. Consigliamo questa configurazione quando hai bisogno di un metastore Hive persistente o un metastore Hive condiviso da diversi cluster, servizi, applicazioni o account. AWS 

Utilizzando Amazon EMR versione 6.5.0 o successiva, puoi configurare Spark per utilizzare il AWS Glue Data Catalog con Apache Iceberg.

Utilizzando Amazon EMR versione 7.5.0 o successiva, puoi configurare Spark per utilizzare il AWS Glue Data Catalog come catalogo Iceberg REST.

AWS Glue è un servizio di estrazione, trasformazione e caricamento (ETL) completamente gestito che rende semplice ed economico classificare i dati, pulirli, arricchirli e spostarli in modo affidabile tra vari archivi di dati. Il AWS Glue Data Catalog fornisce un repository di metadati unificato su una varietà di fonti di dati e formati di dati, che si integra con Amazon EMR, Amazon RDS, Amazon Redshift, Redshift Spectrum, Athena e qualsiasi applicazione compatibile con il metastore Apache Hive. AWS I Glue crawler possono dedurre automaticamente lo schema dai dati di origine in Amazon S3 e archiviare i metadati associati nel Data Catalog. Per ulteriori informazioni sul Data Catalog, consulta [Populating the AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/populate-data-catalog.html) nella *AWS Glue Developer Guide*.

Per AWS Glue si applicano costi separati. È prevista una tariffa mensile per l'archiviazione e l'accesso ai metadati nel Data Catalog, una tariffa oraria fatturata al minuto per i job di AWS Glue ETL e il runtime del crawler e una tariffa oraria fatturata al minuto per ogni endpoint di sviluppo assegnato. Il Data Catalog consente di archiviare fino a un milione di oggetti senza costi aggiuntivi. Se intendi archiviare più di un milione di oggetti, ti verrà addebitato 1 USD per ogni 100.000 oggetti oltre il milione. Un oggetto nel Data Catalog può essere una tabella, una partizione o un database. Per ulteriori informazioni, consulta [Prezzi di Glue](https://aws.amazon.com/glue/pricing).

**Importante**  
Se hai creato tabelle utilizzando Amazon Athena o Amazon Redshift Spectrum prima del 14 agosto 2017, i database e le tabelle vengono archiviati in un catalogo gestito da Athena, separato dal Glue Data Catalog. AWS Per integrare Amazon EMR con queste tabelle, devi eseguire l'upgrade al AWS Glue Data Catalog. Per ulteriori informazioni, consulta [l'aggiornamento al AWS Glue Data Catalog](https://docs.aws.amazon.com/athena/latest/ug/glue-upgrade.html) nella Guida per l'utente di *Amazon Athena*.

## Specificare AWS Glue Data Catalog come metastore Apache Hive
<a name="emr-spark-glue-configure"></a>

Puoi specificare il AWS Glue Data Catalog come metastore utilizzando Console di gestione AWS AWS CLI, o l'API Amazon EMR. Quando si utilizza la CLI o l'API, è possibile utilizzare la classificazione di configurazione per Spark per specificare un Data Catalog. Inoltre, con Amazon EMR 5.16.0 e versioni successive, puoi utilizzare la classificazione di configurazione per specificare un catalogo dati in un altro. Account AWS Quando utilizzi la console, puoi specificare il Data Catalog utilizzando **Advanced Options (Opzioni avanzate)** o **Quick Options (Opzioni rapide)**.

**Nota**  
L'opzione per utilizzare AWS Glue Data Catalog è disponibile anche con Zeppelin perché Zeppelin è installato con componenti Spark.

------
#### [ Console ]

**Per specificare AWS Glue Data Catalog come metastore Apache Hive con la nuova console**

1. [Accedi a e apri Console di gestione AWS la console Amazon EMR su https://console.aws.amazon.com /emr.](https://console.aws.amazon.com/emr)

1. In **Amazon EMR su EC2**, nel riquadro di navigazione a sinistra, scegli **Cluster** e quindi seleziona **Crea cluster**.

1. In **Application bundle** (Bundle di applicazioni), scegli **Spark** o **Custom** (Personalizzato). Se personalizzi il cluster, assicurati di selezionare Zeppelin o Spark come una delle tue applicazioni.

1. In **Impostazioni del Catalogo dati AWS Glue**, seleziona la casella di controllo **Utilizza per i metadati delle tabelle Spark**.

1. Scegli qualsiasi altra opzione applicabile al cluster. 

1. Per avviare il cluster, scegli **Create cluster** (Crea cluster).

------
#### [ AWS CLI ]

**Per specificare il AWS Glue Data Catalog come metastore Apache Hive con AWS CLI**

Per ulteriori informazioni su come specificare una classificazione di configurazione utilizzando l' AWS CLI API Amazon EMR, consulta. [Configurazione delle applicazioni](emr-configure-apps.md)
+ Specificare il valore per `hive.metastore.client.factory.class` utilizzando la classificazione `spark-hive-site` come mostrato nell'esempio seguente:

  ```
  [
    {
      "Classification": "spark-hive-site",
      "Properties": {
        "hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory"
      }
    }
  ]
  ```

  Per specificare un catalogo dati in un AWS account diverso, aggiungi la `hive.metastore.glue.catalogid` proprietà come mostrato nell'esempio seguente. Sostituisci `acct-id` con l'account AWS di Data Catalog.

  ```
  [
    {
      "Classification": "spark-hive-site",
      "Properties": {
        "hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory",
        "hive.metastore.glue.catalogid": "acct-id"
      }
    }
  ]
  ```

------

## Specificare AWS Glue Data Catalog come catalogo Apache Iceberg
<a name="emr-spark-glue-configure-iceberg"></a>

Puoi specificare AWS Glue Data Catalog come implementazione del catalogo Apache Iceberg o come endpoint del catalogo Apache Iceberg REST, utilizzando l' Console di gestione AWS API Amazon EMR o AWS CLI nella configurazione di runtime della sessione Spark. Quando si utilizza la CLI o l'API, è possibile utilizzare la classificazione di configurazione per Spark per specificare un Data Catalog. Per maggiori dettagli, consulta [Specificing AWS Glue Data Catalog come catalogo Apache Iceberg](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-glue.html#emr-spark-glue-configure-iceberg).

## autorizzazioni IAM
<a name="emr-hive-glue-permissions"></a>

Il profilo dell'istanza EC2 per un cluster deve disporre delle autorizzazioni IAM per le azioni AWS Glue. Inoltre, se abiliti la crittografia per gli oggetti di AWS Glue Data Catalog, al ruolo deve essere consentito anche di crittografare, decrittografare e generare ciò che AWS KMS key viene utilizzato per la crittografia.

### Autorizzazioni per le azioni AWS Glue
<a name="emr-hive-glue-permissions-actions"></a>

Se utilizzi il profilo dell'istanza EC2 di default per Amazon EMR, non è richiesta alcuna operazione. La politica `AmazonElasticMapReduceforEC2Role` gestita allegata a `EMR_EC2_DefaultRole` consente tutte le azioni AWS Glue necessarie. Tuttavia, se si specificano un profilo e le autorizzazioni dell'istanza EC2 personalizzati, è necessario configurare le azioni AWS Glue appropriate. Utilizza la policy `AmazonElasticMapReduceforEC2Role` gestita come punto di partenza. Per ulteriori informazioni, consulta [Ruolo di servizio per le istanze EC2 del cluster (profilo dell'istanza EC2)](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-role-for-ec2.html) nella *Guida alla gestione di Amazon EMR*.

### Autorizzazioni per la crittografia e la decrittografia di Glue Data Catalog AWS
<a name="emr-hive-glue-permissions-encrypt"></a>

Il tuo profilo dell'istanza ha bisogno dell'autorizzazione per crittografare e decrittare i dati utilizzando la tua chiave. *Non* è necessario configurare queste autorizzazioni se si applicano entrambe le seguenti istruzioni:
+ È possibile abilitare la crittografia per gli oggetti di AWS Glue Data Catalog utilizzando le chiavi gestite per AWS Glue.
+ Utilizzi un cluster che è Account AWS uguale al AWS Glue Data Catalog.

In caso contrario, devi aggiungere la istruzione seguente alla policy delle autorizzazioni collegata al profilo dell'istanza EC2. 

Per ulteriori informazioni sulla crittografia del AWS Glue Data Catalog, [consulta Encrypting your data catalog](https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html) nella *AWS Glue Developer Guide*.

### Autorizzazioni basate su risorse
<a name="emr-hive-glue-permissions-resource"></a>

Se utilizzi AWS Glue insieme a Hive, Spark o Presto in Amazon EMR, AWS Glue supporta politiche basate sulle risorse per controllare l'accesso alle risorse del Data Catalog. Queste risorse includono tabelle, database, connessioni e funzioni definite dall'utente. Per ulteriori informazioni, consulta [Policy sulle risorse AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-resource-policies.html) nella *Guida per gli sviluppatori di AWS Glue*.

Quando si utilizzano policy basate sulle risorse per limitare l'accesso a AWS Glue dall'interno di Amazon EMR, il principio specificato nella politica delle autorizzazioni deve essere il ruolo ARN associato al profilo dell'istanza EC2 specificato al momento della creazione di un cluster. Ad esempio, per una politica basata sulle risorse allegata a un catalogo, puoi specificare il ruolo ARN per il ruolo di servizio predefinito per le istanze EC2 del cluster, *EMR\$1EC2\$1DefaultRole* come`Principal`, utilizzando il formato mostrato nell'esempio seguente:

```
arn:aws:iam::acct-id:role/EMR_EC2_DefaultRole
```

*acct-id*Può essere diverso dall'ID dell'account AWS Glue. Ciò consente l'accesso da cluster EMR in account diversi. Puoi specificare più entità principali, ognuna da un account diverso.

## Considerazioni sull'utilizzo di AWS Glue Data Catalog
<a name="emr-hive-glue-considerations-hive"></a>

Considera i seguenti elementi quando usi AWS Glue Data Catalog come metastore Apache Hive con Spark:
+ Disporre di un database predefinito senza l'URI del percorso genera errori durante la creazione di una tabella. Per risolvere il problema, utilizza la clausola `LOCATION` per specificare un percorso di bucket, ad esempio `s3://amzn-s3-demo-bucket1`, quando utilizzi `CREATE TABLE`. In alternativa, crea tabelle in un database che non sia quello predefinito.
+ La ridenominazione delle tabelle dall'interno di AWS Glue non è supportata.
+ Quando si crea una tabella Hive senza specificare una `LOCATION`, i dati nella tabella vengono archiviati nella posizione specificata dalla proprietà `hive.metastore.warehouse.dir`. Per impostazione predefinita, questa è una posizione in HDFS. Se un altro cluster necessita di accedere alla tabella, non ci riuscirà a meno che non disponga di autorizzazioni adeguate per il cluster che ha creato la tabella. Inoltre, poiché l'archiviazione HDFS è transitoria, se il cluster viene terminato, i dati della tabella vanno persi e la tabella deve essere ricreata. Ti consigliamo di specificare `LOCATION` a in Amazon S3 quando crei una tabella Hive utilizzando Glue. AWS In alternativa, puoi utilizzare la classificazione di configurazione `hive-site` per specificare una posizione in Amazon S3 per `hive.metastore.warehouse.dir`, che si applica a tutte le tabelle Hive. Se una tabella viene creata in una posizione HDFS e il cluster che l'ha creata è ancora in esecuzione, puoi aggiornare la posizione della tabella su Amazon S3 da Glue. AWS Per ulteriori informazioni, consulta [Working with Tables on the AWS Glue Console](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html) nella *AWS Glue Developer Guide*. 
+ I valori delle partizioni contenenti virgolette e apostrofi non sono supportati, ad esempio `PARTITION (owner="Doe's").`.
+ Le [statistiche di colonna](https://cwiki.apache.org/confluence/display/Hive/StatsDev#StatsDev-ColumnStatistics) sono supportate per emr-5.31.0 e versioni successive.
+ L'utilizzo dell'[autorizzazione Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Authorization) non è supportato. In alternativa, puoi prendere in considerazione l'utilizzo di [Policy basate sulle risorse AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-resource-policies.html). Per ulteriori informazioni, consulta [Use Resource-Based Policies per Amazon EMR Access to AWS](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles-glue.html) Glue Data Catalog.

Considerate quanto segue quando utilizzate AWS Glue Data Catalog come Apache Iceberg REST Catalog con Spark:
+ Se utilizzi il catalogo di sessioni Spark con Iceberg, descritto in[Differenze di configurazione quando si utilizza Iceberg rispetto a SparkCatalog SparkSessionCatalog](emr-iceberg-use-spark-cluster.md#emr-iceberg-spark-catalog), devi configurare il AWS Glue Data Catalog come metastore Apache Hive, oltre a configurare il AWS Glue Data Catalog come catalogo REST di Apache Iceberg.
+ L'endpoint IRC AWS Glue Data Catalog supporta solo lo schema di autenticazione Amazon SigV4. OAuth non è supportato. Per OAuth gli utenti, utilizza IAM Identity Center per configurare l'accesso. Vedi [Connecting Lake Formation con IAM Identity Center](https://docs.aws.amazon.com/lake-formation/latest/dg/connect-lf-identity-center.html).
+ Il catalogo REST di AWS Glue Iceberg non supporta tutte le operazioni in open source.

# Utilizzo di una gerarchia multicatalogo in AWS Glue Data Catalog with Spark su Amazon EMR
<a name="emr-multi-catalog"></a>

Puoi registrare il tuo cluster Amazon EMR per accedere al AWS Glue Data Catalog, che rende disponibili tabelle e altre risorse del catalogo a vari consumatori. AWS Glue Data Catalog supporta una gerarchia multicatalogo, che unifica i dati tra i data lake Amazon S3. Fornisce inoltre sia un'API metastore Hive che un'API REST Apache Iceberg open source per l'accesso ai dati. Queste funzionalità sono disponibili per Amazon EMR e altri servizi come Amazon Athena Amazon Redshift.

## Come sono organizzate le risorse del catalogo
<a name="emr-lakehouse-org"></a>

Quando crei risorse nel AWS Glue Data Catalog, puoi accedervi da qualsiasi motore SQL che supporti l'API REST di Apache Iceberg o il metastore Hive. AWS Lake Formation gestisce le autorizzazioni.

In AWS Glue Data Catalog, i dati sono organizzati in una gerarchia logica di cataloghi, database e tabelle:
+ **Catalogo**: un contenitore logico che contiene oggetti provenienti da un archivio dati, come schemi o tabelle. 
+ **Catalogo per archiviare le tabelle Redshift Managed Storage (RMS)** — Quando gestisci i cataloghi per archiviare le tabelle RMS, puoi accedere a queste tabelle utilizzando Iceberg. 
+ **Database**: organizza oggetti di dati come tabelle e viste in un catalogo.
+ **Tabelle e viste**: oggetti di dati in un database che forniscono un livello di astrazione con uno schema comprensibile. Forniscono un livello per accedere ai dati sottostanti, che possono essere in vari formati e in diverse posizioni.



## Configurazione di un catalogo di dati da utilizzare con Amazon EMR
<a name="emr-lakehouse-configuration"></a>

Per iniziare, configura il catalogo per supportare gli strumenti di Amazon EMR. Il AWS Glue Data Catalog offre la compatibilità con i metastore Hive e la compatibilità con Iceberg REST. APIs 

**Configurazione di Amazon EMR con un metastore Hive**

 Per informazioni su come configurarlo, consulta il [supporto di AWS Glue Data Catalog per i job Spark](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-data-catalog-hive.html) nella AWS Glue User Guide. Questo argomento descrive come configurare AWS Glue Data Catalog come metastore Hive e renderlo disponibile come endpoint. Inoltre, è disponibile la documentazione di Amazon EMR che mostra come specificare AWS Glue Data Catalog come metastore Spark, in Use [the AWS Glue Data Catalog come metastore Apache](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-glue.html) Hive per Spark.

## Autorizzazioni per l'accesso alle risorse in AWS Glue Data Catalog
<a name="emr-lakehouse-using-irc-prereqs"></a>

Questa sezione descrive i requisiti delle policy IAM per l'utilizzo degli strumenti Amazon EMR con i dati del catalogo. Dopo aver registrato il cluster nel AWS Glue Data Catalog, sono necessarie le seguenti autorizzazioni per scoprire la creazione e le modifiche al catalogo di dati creato successivamente: 
+ **colla: GetCatalog**
+ **colla: GetCatalogs**
+ **set: AssumeRole**
+ **set: TagSession**
+ **set: SetContext**
+ **set: SetSourceIdentity**

Nella maggior parte dei casi, quando assegni le autorizzazioni, ti consigliamo di creare un ruolo IAM e di assegnargli le autorizzazioni.

Inoltre, per interrogare i dati del catalogo, è necessario impostare le autorizzazioni per l'utilizzo del catalogo di dati. AWS Lake Formation Per ulteriori informazioni sull'impostazione delle autorizzazioni per i cataloghi di dati in AWS Lake Formation, consulta [Concessione e revoca](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) delle autorizzazioni per le risorse del Catalogo dati.

Dopo aver creato e configurato il cluster e impostato le autorizzazioni per gli oggetti del catalogo, puoi inviare lavori per interrogare ed elaborare i dati.

## Configura Spark per accedere a una gerarchia multicatalogo in AWS Glue Data Catalog
<a name="emr-lakehouse-using-spark-access"></a>

Con EMR 7.5, puoi configurare Spark per utilizzare la gerarchia multicatalogo di AWS Glue. Una gerarchia multicatalogo ti consente di:
+ Trasferisci i tuoi dati Redshift Managed Storage (RMS), come tabelle, viste e viste materializzate dai data warehouse Amazon Redshift esistenti, a Glue Data Catalog. AWS È possibile interrogare questi oggetti utilizzando EMR su EC2 ed EMR Serverless. 
+ Crea cataloghi RMS, AWS Glue Data Catalog e archivia i dati in RMS utilizzando ZeroETL e interroga i dati con motori di query compatibili con Iceberg.
+ Crea tabelle Iceberg gestite in AWS Glue Data Catalog con una gestione dello storage completa che include compattazione, istantanee e conservazione.

### Connessione a multicatalogo quando inizializzi una sessione Spark
<a name="emr-iceberg-initialize-spark-session-spark"></a>

Gli esempi seguenti mostrano come utilizzare la shell interattiva Spark, Spark submit o Amazon EMR Notebooks per lavorare con la gerarchia multicatalogo di Glue. AWS 

------
#### [ spark-shell ]

1. Connessione al nodo master tramite SSH Per ulteriori informazioni, consulta [Connessione al nodo master tramite SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) nella *Guida alla gestione di Amazon EMR*.

1. Immettere il seguente comando per avviare la shell Spark. Per usare la shell, sostituiscila con. PySpark `spark-shell` `pyspark`

   ```
   spark-shell \
       --conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
       --conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket/prefix/
       --conf spark.sql.catalog.my_catalog.type=glue \
       --conf spark.sql.catalog.my_catalog.glue.id=Glue RMS catalog ID \
       --conf spark.sql.defaultCatalog=my_catalog \
       --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
   ```

------
#### [ spark-submit ]

1. Connessione al nodo master tramite SSH Per ulteriori informazioni, consulta [Connessione al nodo master tramite SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) nella *Guida alla gestione di Amazon EMR*.

1. Inserisci il seguente comando per avviare la sessione Spark per Spark.

   ```
   spark-submit \
   --conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
   --conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
   --conf spark.sql.catalog.my_catalog.type=glue \
   --conf spark.sql.catalog.my_catalog.glue.id=Glue RMS catalog ID \
   --conf spark.sql.defaultCatalog=my_catalog \
   --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
   ```

------
#### [ EMR Studio notebooks ]

Per inizializzare una sessione Spark utilizzando i notebook EMR Studio, configurare la sessione Spark utilizzando il comando magico `%%configure` sul tuo notebook Amazon EMR, come nell'esempio seguente. Per ulteriori informazioni, consulta [Utilizzo di EMR Notebooks magics](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-magics.html#emr-magics) nella *Guida alla gestione di Amazon EMR*.

```
%%configure -f{
"conf":{
    "spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
    "spark.sql.catalog.my_catalog.type":"glue",
    "spark.sql.catalog.my_catalog.glue.id":"Glue RMS catalog ID",
    "spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
    "spark.sql.defaultCatalog", "my_catalog",
    "spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
    }
}
```

------
#### [ CLI ]

Per inizializzare una sessione Spark utilizzando la CLI, esegui il seguente esempio. Per ulteriori informazioni su come specificare una classificazione di configurazione utilizzando l' AWS CLI API Amazon EMR, [consulta](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) Configurare le applicazioni.

```
[
  {
    "Classification": "spark-defaults",
    "Properties": {
      "spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
      "spark.sql.catalog.my_catalog.type":"glue",
      "spark.sql.catalog.my_catalog.glue.id":"Glue RMS catalog ID",
      "spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
      "spark.sql.defaultCatalog", "my_catalog",
      "spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
    }
  }
]
```

------

#### Inizializza una sessione Spark su Redshift Managed Storage con Glue Data Catalog AWS
<a name="considerations-multi-catalog-glue-connect"></a>

Il seguente comando di esempio inizializza una sessione Spark con AWS Glue Data Catalog.

```
spark-sql \
  --conf spark.sql.catalog.rms=org.apache.iceberg.spark.SparkCatalog \
  --conf spark.sql.catalog.rms.type=glue \
  --conf spark.sql.catalog.rms.glue.id=Glue RMS catalog ID \
  --conf spark.sql.defaultCatalog=rms
  --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```

L'esempio seguente inizializza una sessione Spark utilizzando l'API REST Iceberg e Redshift Managed Storage with Glue Data Catalog. AWS 

```
spark-sql \
  --conf spark.sql.catalog.rms=org.apache.iceberg.spark.SparkCatalog \
  --conf spark.sql.catalog.rms.type=rest \
  --conf spark.sql.catalog.rms.warehouse=glue RMS catalog ID \
  --conf spark.sql.catalog.rms.uri=Glue endpoint URI/iceberg \
  --conf spark.sql.catalog.rms.rest.sigv4-enabled=true \
  --conf spark.sql.catalog.rms.rest.signing-name=glue \
  --conf spark.sql.defaultCatalog=rms \
  --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```

Per maggiori informazioni sull'utilizzo di una gerarchia multicatalogo AWS Glue con Spark Iceberg, consulta [Usare un cluster Iceberg](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-iceberg-use-spark-cluster.html) con Spark.

## Considerazioni e limitazioni per una configurazione multicatalogo
<a name="considerations-multi-catalog"></a>
+ L'utilizzo di una gerarchia multicatalogo con Apache Hive metastore non è supportato.
+ L'utilizzo di una gerarchia multicatalogo con Apache Iceberg non può supportare il fallback su Apache Hive metastore, quando si utilizza. `SparkSessionCatalog`
+ EMR sui cluster EC2 con ruolo Runtime non supporta la gerarchia multicatalogo.
+ EMR sui cluster EC2 abilitati con AWS Lake Formation non supporta la gerarchia multicatalogo.

# Configurazione di Spark
<a name="emr-spark-configure"></a>

Puoi configurare [Spark su Amazon EMR](https://aws.amazon.com/elasticmapreduce/details/spark/) con le classificazioni di configurazione. Per ulteriori informazioni sulle classificazioni di configurazione, consulta [Configurazione delle applicazioni](emr-configure-apps.md).

Le classificazioni di configurazione per Spark su Amazon EMR includono le seguenti:
+ **`spark`**: imposta la proprietà `maximizeResourceAllocation` su true (vero) o false (falso). Se è true (vero), Amazon EMR configura automaticamente le proprietà `spark-defaults` in base alla configurazione hardware del cluster. Per ulteriori informazioni, consulta [Uso di `maximizeResourceAllocation`](#emr-spark-maximizeresourceallocation).
+ **`spark-defaults`**: imposta valori nel file `spark-defaults.conf`. Per ulteriori informazioni, consulta [Spark configuration (Configurazione di Spark)](https://spark.apache.org/docs/latest/configuration.html) nella documentazione di Spark.
+ **`spark-env`**: imposta valori nel file `spark-env.sh`. Per ulteriori informazioni, consulta [Environment variables (Variabili di ambiente)](https://spark.apache.org/docs/latest/configuration.html#environment-variables) nella documentazione di Spark.
+ **`spark-hive-site`**: imposta valori nel file `hive-site.xml` per Spark.
+ **`spark-log4j`**— (Amazon EMR rilascia 6.7.x e versioni precedenti) Imposta i valori nel file `log4j.properties`. Per ulteriori informazioni, consulta il file [log4j.properties.template](https://github.com/apache/spark/blob/branch-3.2/conf/log4j.properties.template) su Github.
+ **`spark-log4j2`**— (Amazon EMR release 6.8.0 e successive) Imposta i valori nel file `log4j2.properties`. Per ulteriori informazioni, consulta il file [log4j2.properties.template](https://github.com/apache/spark/blob/v3.3.0/conf/log4j2.properties.template) su Github.
+ **`spark-metrics`**: imposta valori nel file `metrics.properties`. Per impostazioni e ulteriori informazioni, consulta il file [metrics.properties.template](https://github.com/apache/spark/blob/master/conf/metrics.properties.template) su Github e la sezione relativa ai [parametri](https://spark.apache.org/docs/latest/monitoring.html#metrics) nella documentazione Spark.

**Nota**  
Se effettui la migrazione dei carichi di lavoro Spark ad Amazon EMR da un'altra piattaforma, ti consigliamo di testare i carichi di lavoro con [Valori di default di Spark impostati da Amazon EMR](#spark-defaults) prima di aggiungere configurazioni personalizzate. La maggior parte dei clienti vede prestazioni migliorate con le nostre impostazioni di default.

**Topics**
+ [Valori di default di Spark impostati da Amazon EMR](#spark-defaults)
+ [Configurazione della garbage collection di Spark su Amazon EMR 6.1.0](#spark-gc-config)
+ [Uso di `maximizeResourceAllocation`](#emr-spark-maximizeresourceallocation)
+ [Configurazione del comportamento di disattivazione di nodi](#spark-decommissioning)
+ [Variabile d'ambiente Spark ThriftServer](#spark-thriftserver)
+ [Modifica delle impostazioni di default di Spark](#spark-change-defaults)
+ [Migrazione da Apache Log4j 1.x a Log4j 2.x](#spark-migrate-logj42)

## Valori di default di Spark impostati da Amazon EMR
<a name="spark-defaults"></a>

Nella tabella seguente viene mostrato in che modo Amazon EMR imposta i valori predefiniti in `spark-defaults` che influenzano le applicazioni.


**Valori di default di Spark impostati da Amazon EMR**  

| Impostazione | Description | Valore predefinito | 
| --- | --- | --- | 
| spark.executor.memory | La quantità di memoria da utilizzare per processo esecutore. Ad esempio, `1g`, `2g`. |  Questa impostazione è determinata dai tipi di istanza principali e dell'attività presenti nel cluster.   | 
| spark.executor.cores | Il numero di core da utilizzare in ogni esecutore. | Questa impostazione è determinata dai tipi di istanza principali e dell'attività presenti nel cluster. | 
| spark.dynamicAllocation.enabled | Se vero, utilizza l'assegnazione di risorse dinamiche, che dimensiona il numero di esecutori registrati con un'applicazione in base al carico di lavoro. |  `true` (con Amazon EMR 4.4.0 e versioni successive)  Il servizio di mescolamento Spark è configurato automaticamente da Amazon EMR.   | 
| spark.sql.hive.advancedPartitionPredicatePushdown.enabled | Se vero, è abilitato il pushdown avanzato dei predicati di partizione nel metastore Hive. | true | 
| spark.sql.hive.stringLikePartitionPredicatePushdown.enabled | Esegue il pushdown dei filtri `startsWith`, `contains` e `endsWith` nel metastore di Hive.  Glue non supporta il pushdown del predicato per `startsWith`, `contains` o `endsWith`. Se utilizzi il metastore Glue e riscontri errori dovuti al pushdown dei predicati per queste funzioni, imposta questa configurazione su `false`.   | true | 

## Configurazione della garbage collection di Spark su Amazon EMR 6.1.0
<a name="spark-gc-config"></a>

L'impostazione di configurazioni di garbage collection personalizzate con `spark.driver.extraJavaOptions` e `spark.executor.extraJavaOptions` genera un errore di avvio del driver o dell'executor con Amazon EMR 6.1 a causa di una configurazione di garbage collection in conflitto con Amazon EMR 6.1.0. Per Amazon EMR 6.1.0, la configurazione predefinita per la rimozione di oggetti inutili (garbage collection) viene impostata tramite `spark.driver.defaultJavaOptions` e `spark.executor.defaultJavaOptions`. Questa configurazione si applica solo ad Amazon EMR 6.1.0. Le opzioni JVM non correlate alla garbage collection, ad esempio quelle per la configurazione della registrazione (`-verbose:class`) possono comunque essere impostate tramite `extraJavaOptions`. Per ulteriori informazioni, consulta [Proprietà dell'applicazione Spark](https://spark.apache.org/docs/latest/configuration.html#application-properties). 

## Uso di `maximizeResourceAllocation`
<a name="emr-spark-maximizeresourceallocation"></a>

Se desideri configurare gli executor per utilizzare la quantità massima delle risorse possibili in ogni nodo di un cluster, imposta `maximizeResourceAllocation` su `true` nella tua classificazione di configurazione `spark`. `maximizeResourceAllocation` è specifico per Amazon EMR. Quando abiliti `maximizeResourceAllocation`, Amazon EMR calcola le risorse di elaborazione e memoria massime per un esecutore su un'istanza nel gruppo di istanze principale. In seguito imposta le impostazioni `spark-defaults` corrispondenti in base ai valori massimi calcolati.

Amazon EMR calcola le risorse di calcolo e memoria massime disponibili per un executor in base a un tipo di istanza del parco istanze principale. Poiché ogni flotta di istanze può avere tipi e dimensioni diverse all'interno di un parco istanze, la configurazione degli esecutori utilizzata da Amazon EMR potrebbe non essere la migliore per i tuoi cluster, quindi non consigliamo di utilizzare le impostazioni predefinite quando utilizzi l'allocazione massima delle risorse. Configura impostazioni personalizzate per i cluster della tua flotta di istanze.

**Nota**  
Non dovresti usare l'`maximizeResourceAllocation`opzione sui cluster con altre applicazioni distribuite come. HBase Amazon EMR utilizza configurazioni YARN personalizzate per applicazioni distribuite, che possono entrare in conflitto con `maximizeResourceAllocation` e causare un funzionamento non corretto delle applicazioni Spark.

Di seguito è riportato un esempio di classificazione della configurazione Spark con `maximizeResourceAllocation` impostato su `true`.

```
[
  {
    "Classification": "spark",
    "Properties": {
      "maximizeResourceAllocation": "true"
    }
  }
]
```


**Impostazioni configurate in `spark-defaults` quando `maximizeResourceAllocation` è abilitata**  

| Impostazione | Description | Valore | 
| --- | --- | --- | 
| spark.default.parallelism | Il numero predefinito di partizioni RDDs viene restituito da trasformazioni come join e parallelize quando non è impostato dall'utente. reduceByKey |  2X numero di core CPU disponibili per i container YARN.  | 
| spark.driver.memory | Quantità di memoria da utilizzare per il processo del driver, ad esempio dove viene inizializzato. SparkContext (ad esempio, 1g, 2g). |  L'impostazione è configurata in base ai tipi di istanza nel cluster. Tuttavia, dato che l'applicazione del driver di Spark può essere eseguita sull'istanza primaria o su una delle istanze core (ad esempio, rispettivamente in modalità cluster e client YARN), l'impostazione è definita in base al tipo di istanza più piccolo in questi due gruppi di istanze.  | 
| spark.executor.memory | Quantità di memoria da utilizzare per processo esecutore, ad esempio 1g, 2g |  L'impostazione è configurata in base ai tipi di istanza principale e di attività nel cluster.   | 
| spark.executor.cores | Il numero di core da utilizzare in ogni esecutore.  | L'impostazione è configurata in base ai tipi di istanza principale e di attività nel cluster.  | 
| spark.executor.instances |  Il numero di esecutori. |  L'impostazione è configurata in base ai tipi di istanza principale e di attività nel cluster. Da impostare, a meno che `spark.dynamicAllocation.enabled` sia esplicitamente impostato su true nello stesso tempo.  | 

## Configurazione del comportamento di disattivazione di nodi
<a name="spark-decommissioning"></a>

Quando si utilizza Amazon EMR versioni 5.9.0 o successive, Spark su Amazon EMR include un set di funzionalità che consentono a Spark di gestire normalmente la terminazione dei nodi dovuta a un ridimensionamento manuale o alla richiesta di una policy di dimensionamento automatico. Amazon EMR implementa un meccanismo di elenco rifiutati in Spark basato sul meccanismo di disattivazione di YARN. Questo meccanismo contribuisce a garantire che nessuna nuova attività sia programmata su un nodo che sarà disattivato, consentendo nel contempo il completamento delle attività in esecuzione. Sono inoltre disponibili caratteristiche che consentono un recupero più rapido dei processi Spark in caso di perdita di blocchi shuffle durante la terminazione di un nodo. Il processo di ricalcolo viene attivato prima e ottimizzato per essere realizzato più rapidamente con un minor numero di tentativi di fase; inoltre, è possibile evitare errori nei processi dovuti a problemi di recupero causati da blocchi shuffle mancanti.

**Importante**  
Ad Amazon EMR rilascio 5.11.0 è stata aggiunta l'impostazione `spark.decommissioning.timeout.threshold` per migliorare la resilienza di Spark quando si utilizzano istanze spot. Nei rilasci precedenti, quando un nodo utilizza un'istanza spot e l'istanza viene terminata a causa del prezzo dell'offerta, è possibile che Spark non riesca a gestire normalmente la terminazione. I processi possono non riuscire e i ricalcoli shuffle possono richiedere una notevole quantità di tempo. Per questo motivo, consigliamo di utilizzare il rilascio 5.11.0 o successivi in caso di impiego delle istanze spot.


**Impostazioni di disattivazione di nodi Spark**  

| Impostazione | Description | Valore predefinito | 
| --- | --- | --- | 
|  `spark.blacklist.decommissioning.enabled`  |  Quando il valore è `true`, Spark elenca come negati i nodi il cui è stato è `decommissioning` in YARN. Spark non pianifica nuove attività su esecutori attivi su quel nodo, ma consente il completamento delle attività già in esecuzione.  |  `true`  | 
|  `spark.blacklist.decommissioning.timeout`  |  Il periodo di tempo durante il quale un nodo il cui stato è `decommissioning` rimane elencato come negato Per impostazione predefinita, questo valore è impostato su un'ora, che è anche l'impostazione predefinita di `yarn.resourcemanager.decommissioning.timeout`. Per garantire che un nodo sia elencato come negato per l'intero periodo di disattivazione, impostare un valore uguale o superiore a `yarn.resourcemanager.decommissioning.timeout`. Alla scadenza del timeout di disattivazione, lo stato del nodo diventa `decommissioned` e Amazon EMR può terminare l'istanza EC2 del nodo. Se una o più attività sono ancora in esecuzione dopo la scadenza del timeout, sono perse oppure terminate e riprogrammate su esecutori attivi su altri nodi.  |  `1h`  | 
|  `spark.decommissioning.timeout.threshold`  |  Disponibile in Amazon EMR rilascio 5.11.0 o successivi. Specificata in secondi. Quando lo stato del nodo diventa "decommissioning" (in disattivazione), se l'host viene disattivato entro un periodo di tempo uguale o inferiore a questo valore, Amazon EMR elenca il nodo come negato e pulisce lo stato dell'host (come specificato da `spark.resourceManager.cleanupExpiredHost`) senza attendere che lo stato del nodo diventi disattivato. Ciò consente a Spark di gestire meglio le terminazioni delle istanze Spot in quanto la disattivazione di tali istanze avviene entro un timeout di 20 secondi indipendentemente dal valore di `yarn.resourcemager.decommissioning.timeout`, che potrebbe non fornire agli altri nodi tempo sufficiente per leggere i file di shuffle.  |  `20s`  | 
|  `spark.resourceManager.cleanupExpiredHost`  |  Quando impostato su `true`, Spark annulla la registrazione di tutti i dati memorizzati nella cache e dei blocchi shuffle archiviati in esecutori sui nodi il cui stato è `decommissioned`. Questa operazione accelera il processo di ripristino.  |  `true`  | 
|  `spark.stage.attempt.ignoreOnDecommissionFetchFailure`  |  Quando impostata su `true`, consente di evitare errori nelle fasi Spark e quindi nel processo dovuti a un numero elevato di recuperi non riusciti da nodi disattivati. I recuperi di blocchi shuffle non riusciti da un nodo il cui stato è `decommissioned` non sono contabilizzati nel numero massimo di errori di recupero consecutivi.  | true | 

## Variabile d'ambiente Spark ThriftServer
<a name="spark-thriftserver"></a>

Spark imposta la variabile di ambiente relativa alla porta del server Hive Thrift, `HIVE_SERVER2_THRIFT_PORT`, su 10001.

## Modifica delle impostazioni di default di Spark
<a name="spark-change-defaults"></a>

Puoi modificare le impostazioni di default in `spark-defaults.conf` utilizzando la classificazione di configurazione `spark-defaults` o l'impostazione `maximizeResourceAllocation` nella classificazione di configurazione `spark`.

Le procedure seguenti mostrano come modificare le impostazioni utilizzando la CLI o la console.

**Creazione di un cluster con spark.executor.memory impostato su 2g utilizzando la CLI**
+ Crea un cluster con Spark installato e `spark.executor.memory` impostato su 2g, utilizzando il comando seguente che fa riferimento a un file, `myConfig.json`, archiviato in Amazon S3.

  ```
  aws emr create-cluster --release-label emr-7.12.0 --applications Name=Spark \
  --instance-type m5.xlarge --instance-count 2 --service-role EMR_DefaultRole_V2 --ec2-attributes InstanceProfile=EMR_EC2_DefaultRole --configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/myfolder/myConfig.json
  ```
**Nota**  
I caratteri di continuazione della riga Linux (\$1) sono inclusi per la leggibilità. Possono essere rimossi o utilizzati nei comandi Linux. Per Windows, rimuoverli o sostituirli con un accento circonflesso (^).

  `myConfig.json`:

  ```
  [
      {
        "Classification": "spark-defaults",
        "Properties": {
          "spark.executor.memory": "2G"
        }
      }
    ]
  ```

**Creazione di un cluster con spark.executor.memory impostato su 2g mediante la console**

1. Passa alla nuova console Amazon EMR e seleziona **Passa alla vecchia console** dalla barra di navigazione laterale. Per ulteriori informazioni su cosa aspettarti quando passi alla vecchia console, consulta [Utilizzo della vecchia console](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).

1. Seleziona **Create cluster** (Crea cluster), **Go to advanced options** (Vai alle opzioni avanzate).

1. Scegliere **Spark**. 

1. In **Edit software settings (Modifica impostazioni software)**, lasciare l'opzione **Enter configuration (Immetti configurazione)** selezionata e immettere la seguente configurazione:

   ```
   classification=spark-defaults,properties=[spark.executor.memory=2G]
   ```

1. Seleziona le altre opzioni, scegli **** e in seguito **Create cluster (Crea cluster)**.

**Impostare maximizeResourceAllocation**
+ Crea un cluster con Spark installato e `maximizeResourceAllocation` impostato su true utilizzando AWS CLI, facendo riferimento a un file`myConfig.json`, archiviato in Amazon S3.

  ```
  aws emr create-cluster --release-label emr-7.12.0 --applications Name=Spark \
  --instance-type m5.xlarge --instance-count 2 --service-role EMR_DefaultRole_V2 --ec2-attributes InstanceProfile=EMR_EC2_DefaultRole --configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/myfolder/myConfig.json
  ```
**Nota**  
I caratteri di continuazione della riga Linux (\$1) sono inclusi per questioni di leggibilità. Possono essere rimossi o utilizzati nei comandi Linux. Per Windows, rimuoverli o sostituirli con un accento circonflesso (^).

  `myConfig.json`:

  ```
  [
    {
      "Classification": "spark",
      "Properties": {
        "maximizeResourceAllocation": "true"
      }
    }
  ]
  ```

**Nota**  
Con Amazon EMR versione 5.21.0 e successive, puoi sovrascrivere le configurazioni del cluster e specificare classificazioni di configurazione aggiuntive per ogni gruppo di istanze in un cluster in esecuzione. A tale scopo, puoi utilizzare la console Amazon EMR, AWS Command Line Interface (AWS CLI) o l' AWS SDK. Per ulteriori informazioni, consulta [Specifica di una configurazione per un gruppo di istanze in un cluster in esecuzione](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps-running-cluster.html).

## Migrazione da Apache Log4j 1.x a Log4j 2.x
<a name="spark-migrate-logj42"></a>

Le versioni [Apache Spark](https://aws.amazon.com/emr/features/spark/) 3.2.x e precedenti utilizzano la versione precedente di Apache Log4j 1.x e il file `log4j.properties` per configurare Log4j nei processi Spark. Le versioni 3.3.0 e successive di Apache Spark utilizzano Apache Log4j 2.x e il file `log4j2.properties` per configurare Log4j nei processi Spark.

Se hai configurato Apache Spark Log4j utilizzando una versione Amazon EMR precedente alla 6.8.0, devi rimuovere la classificazione della configurazione `spark-log4j` legacy e migrazione alla classificazione della configurazione `spark-log4j2` e formato delle chiavi prima di poter effettuare l'aggiornamento ad Amazon EMR 6.8.0 o versione successiva. La classificazione `spark-log4j` legacy causa il fallimento della creazione del cluster con un errore `ValidationException` nel rilascio di Amazon EMR versione 6.8.0 e successive. Non ti verrà addebitato alcun costo per un guasto relativo all'incompatibilità di Log4j, ma devi rimuovere la classificazione della configurazione `spark-log4j` passata per continuare.

Per ulteriori informazioni sulla migrazione da Apache Log4j 1.x a Log4j 2.x, consulta [Guida alla migrazione per Apache Log4j](https://logging.apache.org/log4j/2.x/manual/migration.html) e il [Modello Spark Log4j 2](https://github.com/apache/spark/blob/master/conf/log4j2.properties.template) su GitHub. 

**Nota**  
Con Amazon EMR, Apache Spark utilizza un file `log4j2.properties` anziché il file .xml descritto nella [Guida alla migrazione per Apache Log4j](https://logging.apache.org/log4j/2.x/manual/migration.html). Inoltre, non è consigliabile utilizzare il metodo bridge Log4j 1.x per la conversione in Log4j 2.x. 

# Cos'è l'agente di risoluzione dei problemi di Apache Spark per Amazon EMR?
<a name="spark-troubleshoot"></a>

## Introduzione
<a name="spark-troubleshooting-agent-intro"></a>

L'agente di risoluzione dei problemi di Apache Spark per Amazon EMR è una funzionalità di intelligenza artificiale conversazionale che semplifica la risoluzione dei problemi delle applicazioni Apache Spark su Amazon EMR, Glue e Amazon Notebooks. AWS SageMaker La risoluzione dei problemi tradizionali di Spark richiede un'analisi manuale approfondita dei log, delle metriche delle prestazioni e dei modelli di errore per identificare le cause principali e le correzioni del codice. L'agente semplifica questo processo tramite istruzioni in linguaggio naturale, analisi automatizzata del carico di lavoro e consigli intelligenti sul codice.

È possibile utilizzare l'agente per risolvere PySpark i problemi e gli errori delle applicazioni Scala. L'agente analizza i lavori non riusciti, identifica i punti deboli in termini di prestazioni e fornisce consigli pratici e correzioni di codice, dandoti il pieno controllo sulle decisioni di implementazione.

**Nota**  
L'agente di risoluzione dei problemi di Apache Spark è disponibile senza costi aggiuntivi come parte di Amazon EMR. L'agente fornisce solo analisi e consigli. Paghi solo per le risorse Amazon EMR che utilizzi quando esegui le tue applicazioni per convalidare le correzioni consigliate.

## Panoramica dell'architettura
<a name="spark-troubleshooting-agent-architecture"></a>

L'agente di risoluzione dei problemi ha tre componenti principali: un assistente AI compatibile con MCP nell'ambiente di sviluppo per l'interazione, il [proxy MCP AWS](https://github.com/aws/mcp-proxy-for-aws) che gestisce la comunicazione e l'autenticazione sicure tra il client e i AWS servizi e il server MCP remoto Amazon SageMaker Unified Studio `(preview)` che fornisce strumenti di risoluzione dei problemi Spark specializzati per Amazon EMR, Glue e Amazon Notebooks. AWS SageMaker Questo diagramma illustra come interagisci con il server MCP remoto Amazon SageMaker Unified Studio tramite AI Assistant.

![\[Architettura dell'agente di risoluzione dei problemi di Spark.\]](http://docs.aws.amazon.com/it_it/emr/latest/ReleaseGuide/images/spark-troubleshooting-agent-architecture.png)


L'assistente AI orchestrerà la risoluzione dei problemi utilizzando strumenti specializzati forniti dal server MCP seguendo questi passaggi:
+ **Estrazione delle funzionalità e creazione del contesto:** l'agente raccoglie e analizza automaticamente i dati di telemetria dall'applicazione Spark, inclusi i log dello Spark History Server, le impostazioni di configurazione e le tracce di errore. Estrae le metriche chiave delle prestazioni, i modelli di utilizzo delle risorse e le firme di errore per creare un profilo contestuale completo per una risoluzione intelligente dei problemi.
+ **Analizzatore GenAI Root Cause e Recommendation Engine:** l'agente sfrutta i modelli di intelligenza artificiale e la knowledge base Spark per correlare le funzionalità estratte e identificare le cause principali dei problemi o degli errori di prestazioni. Fornisce approfondimenti diagnostici e analisi di ciò che è andato storto nell'esecuzione dell'applicazione Spark.
+ **Raccomandazione del codice GenAI Spark:** in base all'analisi della causa principale del passaggio precedente, l'agente analizza i modelli di codice esistenti e identifica le operazioni inefficienti che richiedono correzioni di codice per gli errori delle applicazioni. Fornisce consigli pratici tra cui modifiche specifiche al codice, aggiustamenti della configurazione e miglioramenti dell'architettura con esempi concreti.

**Topics**
+ [Introduzione](#spark-troubleshooting-agent-intro)
+ [Panoramica dell'architettura](#spark-troubleshooting-agent-architecture)
+ [Configurazione dell'agente di risoluzione dei problemi](spark-troubleshooting-agent-setup.md)
+ [Utilizzo dell'agente di risoluzione dei problemi](spark-troubleshooting-using-troubleshooting-agent.md)
+ [Caratteristiche e funzionalità](spark-troubleshooting-features.md)
+ [Risoluzione dei problemi e domande e risposte](spark-troubleshooting-agent-troubleshooting.md)
+ [Il flusso di lavoro dell'agente di risoluzione dei problemi di Spark in dettaglio](spark-troubleshooting-agent-workflow.md)
+ [Esempi rapidi](spark-troubleshooting-agent-prompt-examples.md)
+ [Configurazione del ruolo IAM](spark-troubleshooting-agent-iam-setup.md)
+ [Utilizzo degli strumenti di risoluzione dei problemi di Spark](spark-troubleshooting-agent-using-tools.md)
+ [Configurazione degli endpoint VPC dell'interfaccia per SageMaker Amazon Unified Studio MCP](spark-troubleshooting-agent-vpc-endpoints.md)
+ [Elaborazione interregionale per l'agente di risoluzione dei problemi di Apache Spark](spark-troubleshooting-cross-region-processing.md)
+ [Registrazione delle chiamate MCP di Amazon SageMaker Unified Studio tramite AWS CloudTrail](spark-troubleshooting-cloudtrail-integration.md)
+ [Miglioramenti del servizio per gli agenti Apache Spark](spark-agents-service-improvements.md)

# Configurazione dell'agente di risoluzione dei problemi
<a name="spark-troubleshooting-agent-setup"></a>

**Nota**  
L'agente di risoluzione dei problemi di Apache Spark utilizza l'inferenza interregionale per elaborare le richieste in linguaggio naturale e generare risposte. Per ulteriori dettagli, fare riferimento a. [Elaborazione interregionale per l'agente di risoluzione dei problemi di Apache Spark](spark-troubleshooting-cross-region-processing.md) Il server MCP Amazon SageMaker Unified Studio è disponibile in anteprima ed è soggetto a modifiche.

## Prerequisiti
<a name="spark-troubleshooting-agent-prerequisites"></a>

Prima di iniziare il nostro processo di configurazione per l'integrazione con Kiro CLI, assicurati di avere installato quanto segue sulla tua workstation:
+  [Installa AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) 
+  [Installa Python 3.10\$1](https://www.python.org/downloads/release/python-3100/) 
+  [Installa il gestore di `uv` pacchetti per MCP Proxy](https://docs.astral.sh/uv/getting-started/installation/) [per AWS](https://github.com/aws/mcp-proxy-for-aws?tab=readme-ov-file) 
+  [Installa Kiro CLI](https://kiro.dev/docs/cli/) 
+ AWS credenziali locali configurate (tramite [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html), variabili di ambiente o ruoli IAM) - per operazioni locali come il caricamento di artefatti di lavoro aggiornati per l'esecuzione di processi di convalida EMR.

## Risorse per l'installazione
<a name="spark-troubleshooting-agent-setup-resources"></a>

È possibile utilizzare un AWS CloudFormation modello per configurare la risorsa per il server MCP. Questi modelli sono esempi che è necessario modificare per soddisfare i requisiti. Il modello crea le seguenti risorse per il processo di risoluzione dei problemi:

1. Ruolo IAM che dispone delle autorizzazioni per chiamare MCP Server e delle autorizzazioni necessarie per il processo di risoluzione dei problemi per la piattaforma selezionata.

Scegli uno dei pulsanti **Launch Stack (Avvia stack)** nella tabella seguente. Questo avvia lo stack sulla AWS CloudFormation console nella rispettiva regione.


| Region | Avvia | 
| --- | --- | 
| Stati Uniti orientali (Ohio) |  [https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Stati Uniti orientali (Virginia settentrionale) |  [https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Stati Uniti occidentali (Oregon) |  [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Asia Pacifico (Tokyo) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Europa (Irlanda) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Asia Pacifico (Singapore) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Asia Pacifico (Sydney) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Canada (Centrale) |  [https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Sud America (San Paolo) |  [https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Europa (Francoforte) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Europa (Stoccolma) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Europa (Londra) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Europa (Parigi) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Asia Pacifico (Seul) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 
| Asia Pacifico (Mumbai) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup)  | 

**Vai alla pagina **Specificare i dettagli dello stack**, inserisci il nome dello stack.** Inserisci informazioni aggiuntive sotto **Parameters (Parametri)**. Fornisci le seguenti informazioni e procedi con la creazione dello stack.
+ **TroubleshootingRoleName**- Nome del ruolo IAM da creare per le operazioni di risoluzione dei problemi
+ **AbilitaEMREC2: abilita** le autorizzazioni per la risoluzione dei problemi EMR-EC2 (impostazione predefinita: true)
+ **AbilitaEMRServerless: abilita** le autorizzazioni per la risoluzione dei problemi senza server EMR (impostazione predefinita: true)
+ **EnableGlue**- Abilita le autorizzazioni per la risoluzione dei problemi di Glue (impostazione predefinita: true)
+ **CloudWatchKmsKeyArn**- (Facoltativo) ARN della chiave KMS esistente per la CloudWatch crittografia dei registri (solo EMR Serverless, lascia vuoto per la crittografia predefinita)

Puoi anche scaricare e rivedere [il CloudFormation modello](https://github.com/aws-samples/aws-emr-utilities/blob/03c20fece616de23ec0ea5389f0113a5bc65fc3a/utilities/apache-spark-agents/spark-troubleshooting-agent-cloudformation/spark-troubleshooting-mcp-setup.yaml), specificare le opzioni sopra e avviare il modello da solo con i comandi CloudFormation CLI, vedi sotto per un esempio:

```
# deploy the stack with CloudFormation CLI commands
aws cloudformation deploy \
  --template-file spark-troubleshooting-mcp-setup.yaml \
  --stack-name spark-troubleshooting-mcp-setup \
  --region <your Spark MCP server launch region> \
  --capabilities CAPABILITY_NAMED_IAM \
  --parameter-overrides \
    TroubleshootingRoleName=spark-troubleshooting-role


# retrieve the 1-line instruction to set the local environment variables, which will be used for the following MCP server configuration
aws cloudformation describe-stacks \
  --stack-name spark-troubleshooting-mcp-setup \
  --region <your Spark MCP server launch region> \
  --query "Stacks[0].Outputs[?OutputKey=='ExportCommand'].OutputValue" \
  --output text
```

Apri la scheda Output (o recupera dal comando CLI CloudFormation describe-stacks sopra) e copia l'istruzione a 1 riga dall' CloudFormation output per impostare le variabili di ambiente, quindi eseguila nell'ambiente locale. Esempio di istruzione a 1 riga:

```
export SMUS_MCP_REGION=<your mcp server launch region> && export IAM_ROLE=arn:aws:iam::111122223333:role/spark-troubleshooting-role-xxxxxx
```

Quindi esegui il seguente comando localmente per configurare il profilo IAM e la configurazione del server MCP:

```
# Step 1: Configure AWS CLI Profile
aws configure set profile.smus-mcp-profile.role_arn ${IAM_ROLE}
aws configure set profile.smus-mcp-profile.source_profile <AWS CLI Profile to assume the IAM role - ex: default>
aws configure set profile.smus-mcp-profile.region ${SMUS_MCP_REGION}

# Step 2: if you are using kiro CLI, use the following command to add the MCP configuration
# Add Spark Troubleshooting MCP Server
kiro-cli-chat mcp add \
    --name "sagemaker-unified-studio-mcp-troubleshooting" \
    --command "uvx" \
    --args "[\"mcp-proxy-for-aws@latest\",\"https://sagemaker-unified-studio-mcp.${SMUS_MCP_REGION}.api.aws/spark-troubleshooting/mcp\", \"--service\", \"sagemaker-unified-studio-mcp\", \"--profile\", \"smus-mcp-profile\", \"--region\", \"${SMUS_MCP_REGION}\", \"--read-timeout\", \"180\"]" \
    --timeout 180000 \
    --scope global
    
# Add Spark Code Recommendation MCP Server
kiro-cli-chat mcp add \
    --name "sagemaker-unified-studio-mcp-code-rec" \
    --command "uvx" \
    --args "[\"mcp-proxy-for-aws@latest\",\"https://sagemaker-unified-studio-mcp.${SMUS_MCP_REGION}.api.aws/spark-code-recommendation/mcp\", \"--service\", \"sagemaker-unified-studio-mcp\", \"--profile\", \"smus-mcp-profile\", \"--region\", \"${SMUS_MCP_REGION}\", \"--read-timeout\", \"180\"]" \
    --timeout 180000 \
    --scope global
```

Questo dovrebbe `~/.kiro/settings/mcp.json` aggiornarsi per includere la configurazione del server MCP come di seguito.

```
{
  "mcpServers": {
    "sagemaker-unified-studio-mcp-troubleshooting": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "mcp-proxy-for-aws@latest",
        "https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-troubleshooting/mcp",
        "--service",
        "sagemaker-unified-studio-mcp",
        "--profile",
        "smus-mcp-profile",
        "--region",
        "us-east-1",
        "--read-timeout",
        "180"
      ],
      "timeout": 180000,
      "disabled": false
    },
    "sagemaker-unified-studio-mcp-code-rec": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "mcp-proxy-for-aws@latest",
        "https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-code-recommendation/mcp",
        "--service",
        "sagemaker-unified-studio-mcp",
        "--profile",
        "smus-mcp-profile",
        "--region",
        "us-east-1",
        "--read-timeout",
        "180"
      ],
      "timeout": 180000,
      "disabled": false
    }
  }
}
```

Consulta [Interfacce supportate](spark-troubleshooting-using-troubleshooting-agent.md#supported-interfaces) la guida alla configurazione per diversi client MCP come Kiro, Cline e. GitHub CoPilot

# Utilizzo dell'agente di risoluzione dei problemi
<a name="spark-troubleshooting-using-troubleshooting-agent"></a>

## Modalità di distribuzione supportate
<a name="supported-deployment-modes"></a>

Apache Spark Troubleshooting Agent per Amazon EMR supporta funzionalità di analisi complete per i carichi di lavoro Spark non riusciti, tra cui la diagnosi automatizzata degli errori, l'identificazione dei punti critici delle prestazioni, consigli sui codici e suggerimenti pratici per migliorare le prestazioni delle applicazioni per la seguente modalità di distribuzione Spark:
+ EMR su EC2
+ EMR Serverless
+ AWS Glue

Si prega di fare riferimento [Caratteristiche e funzionalità](spark-troubleshooting-features.md) a per comprendere le caratteristiche, le capacità e le limitazioni dettagliate.

## Interfacce supportate
<a name="supported-interfaces"></a>

### Risoluzione dei problemi relativi alle celle all'interno di Amazon SageMaker Notebooks
<a name="troubleshooting-sagemaker-notebooks"></a>

Una dimostrazione dell'esperienza di risoluzione dei problemi con Amazon SageMaker Notebooks. Per qualsiasi guasto della cella Notebook, puoi chiedere ad Amazon SageMaker Notebook Agent di risolvere il problema e richiedere l'analisi seguita dall'eventuale correzione del codice se l'errore è dovuto al codice, facendo clic sul `Fix with AI` pulsante.

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/btW8hwio0tE/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/btW8hwio0tE)


### Risoluzione dei problemi delle applicazioni Glue ed EMR Spark con la CLI di Kiro
<a name="troubleshooting-glue-emr-applications"></a>

Avvia Kiro CLI o il tuo AI Assistant e verifica gli strumenti caricati per il processo di risoluzione dei problemi.

```
...
 sagemaker-unified-studio-mcp-code-rec (MCP)
 - spark_code_recommendation    not trusted
 
 sagemaker-unified-studio-mcp-troubleshooting (MCP)
 - analyze_spark_workload       not trusted
...
```

Ora sei pronto per avviare il flusso di lavoro dell'agente di risoluzione dei problemi di Spark.

Una dimostrazione dell'esperienza di risoluzione dei problemi con Kiro CLI. Puoi semplicemente avviare il processo di risoluzione dei problemi con la seguente richiesta:

```
Analyze my Glue job. The job name is "xxx" and the job run id is "xxx"
```

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/YLwV_EenJXY/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/YLwV_EenJXY)


### Integrazione con altri client MCP
<a name="integration-other-mcp-clients"></a>

La configurazione descritta in [Configurazione dell'agente di risoluzione dei problemi](spark-troubleshooting-agent-setup.md) può essere utilizzata anche in altri client MCP e IDEs per connettersi al server MCP gestito:
+ **Integrazione con Cline**: per utilizzare il server MCP con Cline, modifica `cline_mcp_settings.json` e aggiungi la configurazione precedente. Consultate [la documentazione di Cline](https://docs.cline.bot/mcp/configuring-mcp-servers) per ulteriori informazioni su come gestire la configurazione MCP.
+ **Integrazione con Claude Code** Per utilizzare il server MCP con Claude Code, modifica il file di configurazione per includere la configurazione MCP. Il percorso del file varia a seconda del sistema operativo. Per una configurazione dettagliata, fare riferimento a [ https://code.claude.com/docs/en/mcp](https://code.claude.com/docs/en/mcp).
+ **Integrazione con GitHub Copilot** - Per utilizzare il server MCP con GitHub Copilot, segui le istruzioni contenute in [ https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend- copilot-chat-with-mcp](https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend-copilot-chat-with-mcp) per modificare il file di configurazione corrispondente e segui le istruzioni di ciascun IDE per attivare la configurazione.

# Caratteristiche e funzionalità
<a name="spark-troubleshooting-features"></a>

## Piattaforme supportate
<a name="supported-platforms"></a>
+ **Linguaggi**: applicazioni Python e Scala Spark
+ **Piattaforme target**: Amazon EMR, EMR Serverless e Glue AWS 

## Come funziona
<a name="how-it-works"></a>

Quando l'applicazione Spark si guasta, puoi utilizzare l'agente di risoluzione dei problemi per indagare automaticamente su cosa è andato storto. Analizza i registri degli eventi di Spark, i messaggi di errore e l'utilizzo delle risorse per individuare il problema esatto, che si tratti di un esecutore Spark che sta esaurendo la memoria, di un errore di configurazione o di un bug del codice.

Quando richiedi un prompt in linguaggio naturale per analizzare il tuo carico di lavoro Spark, l'agente si connette alle risorse della tua piattaforma ed estrae le funzionalità (che includono registri degli eventi Spark, piani di query, timeline degli esecutori, tracce di registro, configurazioni e metriche):
+ Su EMR-EC2: si connette all'interfaccia utente persistente [EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html) per il cluster
+ On Glue: crea il contesto dall'[interfaccia utente Spark](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html) di Glue Studio per il lavoro
+ [Su EMR-Serverless: si connette allo Spark History Server EMR-Serverless per il lavoro](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_GetDashboardForJobRun.html)
+ L'agente analizza anche le tracce dello stack di errori e i dettagli di configurazione per fornirti informazioni utili.

Per i carichi di lavoro non riusciti, ottieni una chiara spiegazione della causa principale e i passaggi specifici per risolverli. Se l'agente rileva un problema relativo al codice, fornisce automaticamente consigli sul codice per mostrarti esattamente cosa modificare nel codice. Puoi anche richiedere suggerimenti a livello di codice direttamente ogni volta che li desideri senza l'analisi completa.

## Regioni disponibili
<a name="available-regions"></a>

Lo Spark Troubleshooting Agent è disponibile nelle seguenti regioni:
+ **Asia Pacifico**: Tokyo (ap-northeast-1), Seul (ap-northeast-2), Singapore (ap-southeast-1), Sydney (ap-southeast-2) e Mumbai (ap-southeast-2) e Mumbai (ap-south-1)
+ **Nord America**: Canada (ca-central-1)
+ **Europa**: Stoccolma (eu-north-1), Irlanda (eu-west-1), Londra (eu-west-2), Parigi (eu-west-3) e Francoforte (eu-central-1)
+ **Sud America**: San Paolo (sa-east-1)
+ **Stati Uniti**: Virginia del Nord (us-east-1), Ohio (us-east-2) e Oregon (us-west-2)

## Ambito di applicazione della risoluzione dei problemi di Spark e requisiti utente
<a name="scope-requirements"></a>
+ **Stati di carico di lavoro Spark supportati: gli** strumenti supporteranno solo le risposte per i carichi di lavoro Spark non riusciti.
+ **Interfaccia utente persistente EMR: durante l'analisi dei carichi di lavoro di Amazon EMR-EC2, lo strumento di analisi tenterà di connettersi all'interfaccia utente persistente** EMR per recuperare le informazioni chiave di Spark. [Le considerazioni relative all'interfaccia utente persistente di EMR sono documentate qui.](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html#app-history-spark-UI-limitations)
+ **Interfaccia utente Glue Studio Spark**: durante l'analisi dei carichi di lavoro di AWS Glue, lo strumento di analisi tenterà di recuperare le informazioni chiave di Spark analizzando i registri degli eventi Spark dell'utente da Amazon S3. [La dimensione massima consentita del registro degli eventi Spark è documentata qui: 512 MB e 2 GB per i log in sequenza.](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html)
+ **Codice consigliato:** supportato solo per i carichi di lavoro Amazon EMR-EC2 e AWS Glue per carichi di lavoro PySpark 
+ **Risorse regionali:** lo Spark Troubleshooting Agent è regionale e utilizza le risorse EMR sottostanti in quella regione per il processo di risoluzione dei problemi. La risoluzione dei problemi tra aree geografiche non è supportata.

# Risoluzione dei problemi e domande e risposte
<a name="spark-troubleshooting-agent-troubleshooting"></a>

## Risoluzione dei problemi
<a name="spark-troubleshooting-common-issues"></a>

Il messaggio di errore di Spark Troubleshooting Agent è disponibile in diversi modi per diversi client MCP. In questa pagina, elenchiamo alcune linee guida generali per i problemi più comuni che potresti riscontrare utilizzando l'agente di risoluzione dei problemi Apache Spark per Amazon EMR.

Argomenti
+ [Errore: caricamento del server MCP non riuscito](#mcp-server-failed-to-load)
+ [Osservazione: caricamento lento dell'utensile](#slow-tool-loading)
+ [Errore: invocazione dello strumento non riuscita con errore di limitazione](#throttling-error)
+ [Errore: lo strumento risponde con un errore dell'utente](#user-error)
+ [Errore: lo strumento risponde con un errore interno](#internal-error)

### Errore: caricamento del server MCP non riuscito
<a name="mcp-server-failed-to-load"></a>
+ Verificate che le configurazioni MCP siano configurate correttamente.
+ **Convalida la sintassi JSON**:
  + Assicurati che il tuo JSON sia valido senza errori di sintassi
  + Verifica la presenza di virgole, virgolette o parentesi mancanti
+ Verifica le tue AWS credenziali locali e verifica che la policy per il ruolo MCP IAM sia configurata correttamente.
+ Esegui /mcp per verificare la disponibilità del server MCP per ogni caso `Kiro-CLI`

### Osservazione: caricamento lento dell'utensile
<a name="slow-tool-loading"></a>
+ Il caricamento degli strumenti potrebbe richiedere alcuni secondi al primo tentativo di avvio del server.
+ Se gli strumenti non vengono visualizzati, prova a riavviare la chat.
+ Esegui `/tools` il comando per verificare la disponibilità dello strumento.
+ Esegui `/mcp` se il server viene avviato senza errori.

### Errore: invocazione dello strumento non riuscita con errore di limitazione
<a name="throttling-error"></a>
+ Se hai raggiunto il limite di servizio, attendi qualche secondo prima di invocare lo strumento se vedi l'eccezione di limitazione.

### Errore: lo strumento risponde con un errore dell'utente
<a name="user-error"></a>
+ AccessDeniedException - controlla il messaggio di errore e risolvi il problema di autorizzazione.
+ InvalidInputException - controlla il messaggio di errore e correggi i parametri di immissione dell'utensile.
+ ResourceNotFoundException - controlla il messaggio di errore e correggi il parametro di input per il riferimento alle risorse.

### Errore: lo strumento risponde con un errore interno
<a name="internal-error"></a>
+ Se lo vedi, `The service is handling high-volume requests` riprova a richiamare lo strumento tra qualche secondo.
+ Se lo `INTERNAL SERVICE EXCEPTION` vedi, documenta l'ID di analisi, il nome dello strumento, qualsiasi messaggio di errore disponibile nel registro mcp o nella risposta dello strumento e, facoltativamente, la cronologia delle conversazioni ripulita e completa, e contatta l'assistenza. AWS 

## DOMANDE E RISPOSTE
<a name="spark-troubleshooting-qa"></a>

### 1. Devo abilitare l'impostazione «trust» per gli strumenti per impostazione predefinita?
<a name="qa-trust-setting"></a>

Inizialmente non attivate l'impostazione «trust» per impostazione predefinita per tutte le chiamate agli strumenti e utilizzate un ambiente di compilazione con versione git quando accettate i consigli sul codice. Esamina l'esecuzione di ogni strumento per capire quali modifiche vengono apportate.

### 2. Quali sono gli esempi più comuni per sfruttare gli strumenti di risoluzione dei problemi?
<a name="qa-example-prompts"></a>

Per i rapidi esempi sull'utilizzo degli [Esempi rapidi](spark-troubleshooting-agent-prompt-examples.md) strumenti di risoluzione dei problemi, fate riferimento a:

### 3. Quali dati vengono trasmessi al LLM e come vengono gestiti?
<a name="qa-data-transmitted-to-llm"></a>

I dati e i file dei clienti rimangono nella AWS regione prescelta e non vengono trasmessi tra le regioni. Quando l'agente opera in una regione che utilizza l'inferenza globale tra regioni da Amazon Bedrock, il servizio può indirizzare le richieste alla regione più vicina con capacità disponibile a seconda della domanda. In questi casi, vengono trasmessi solo i metadati estratti dai log dei clienti e dai risultati di inferenza elaborati, non i dati o i file sottostanti del cliente. Tutti i dati vengono mascherati con PII prima di essere inviati al LLM per l'elaborazione, indipendentemente dal fatto che l'inferenza avvenga all'interno della stessa regione o venga instradata verso un'altra regione. Per ulteriori dettagli su come funziona l'inferenza interregionale e su quali regioni sono interessate, vedere. [Elaborazione interregionale per l'agente di risoluzione dei problemi di Apache Spark](spark-troubleshooting-cross-region-processing.md)

# Il flusso di lavoro dell'agente di risoluzione dei problemi di Spark in dettaglio
<a name="spark-troubleshooting-agent-workflow"></a>

Per avviare il processo di risoluzione dei problemi, è necessario accedere agli identificatori delle applicazioni Spark non funzionanti in esecuzione su piattaforme supportate (EMR-EC2, EMR Serverless, AWS Glue o Amazon Data Notebooks). SageMaker L'applicazione deve avere log accessibili, Spark History Server e dettagli di configurazione. Assicurati di disporre delle autorizzazioni necessarie per accedere alle risorse della piattaforma e ai metadati dell'applicazione. Una volta stabiliti questi requisiti, puoi inviare una richiesta come la seguente per avviare il flusso di lavoro di risoluzione dei problemi:

```
Analyze my EMR step execution failure, EMR id <step-id> with cluster id <cluster-id>
```

A questo punto, l'agente orchestrerà la risoluzione dei problemi utilizzando strumenti specializzati. Il flusso di lavoro segue questi passaggi:

1. **Estrazione delle funzionalità e creazione del contesto**: l'agente raccoglie e analizza automaticamente i dati di telemetria dall'applicazione Spark, inclusi i log di History Server, le impostazioni di configurazione e le tracce di errore. Vedrai lo strumento raccogliere informazioni sulle metriche delle prestazioni, sui modelli di utilizzo delle risorse e sulle firme di errore.

1. **Analisi e identificazione delle cause principali: l'**agente sfrutta i modelli di intelligenza artificiale e la knowledge base Spark per correlare le funzionalità estratte e identificare le cause principali dei problemi o degli errori di prestazioni. Riceverai:
   + **Analisi approfondite**: dettagli tecnici su ciò che l'agente ha scoperto e analizzato.
   + **Causa principale**: spiegazione chiara di cosa è andato storto e perché.
   + **Valutazione iniziale**: indipendentemente dal fatto che il problema sia correlato al codice, alla configurazione o alle risorse, verranno fornite alcune linee guida e analisi generali per la mitigazione.

1. **Raccomandazioni sul codice** (se applicabile): se l'analisi identifica problemi relativi al codice in base alla classificazione degli errori, l'agente può suggerire di utilizzare lo strumento di raccomandazione del codice per fornire consigli specifici per implementare la correzione del codice consigliata con codice esatto e sostituzioni suggerite. before/after 

Il processo di risoluzione dei problemi è iterativo: puoi continuare la conversazione per approfondire problemi specifici; puoi anche utilizzare gli strumenti in modo interattivo nello sviluppo del nostro codice Spark locale per correggere i bug del codice o migliorare continuamente il codice.

# Esempi rapidi
<a name="spark-troubleshooting-agent-prompt-examples"></a>

Di seguito è riportato un elenco di esempi rapidi che possono essere utilizzati nell'esperienza di risoluzione dei problemi.

## 1. Risolvi l'errore di esecuzione del job Spark
<a name="troubleshoot-job-failure"></a>

Risoluzione dei problemi EMR su EC2:

```
Troubleshoot my EMR-EC2 step with id s-xxxxxxxxxxxx on cluster j-xxxxxxxxxxxxx
```

Risoluzione dei problemi di Glue Job:

```
Troubleshoot my Glue job with job run id jr_xxxxxxxxxxxxxxxxxxxxxxxxxxxx and job name test_job
```

Risoluzione dei problemi EMR Serverless:

```
Troubleshoot my EMR-Serverless job run with application id 00xxxxxxxx and job run id 00xxxxxxxx
```

## 2. Richiesta di raccomandazione per la correzione del codice
<a name="request-code-fix"></a>

Richiedi una raccomandazione per la correzione del codice per EMR su un job EC2:

```
Recommend code fix for my EMR-EC2 step with id s-STEP_ID on cluster j-CLUSTER_ID
```

Richiedi un consiglio per la correzione del codice per Glue job:

```
Recommend code fix for my Glue job with job run id jr_JOB_RUN_ID and job name test_job
```

# Configurazione del ruolo IAM
<a name="spark-troubleshooting-agent-iam-setup"></a>

Lo CloudFormation stack di istruzioni di installazione automatizza la configurazione dei ruoli IAM per te. Se desideri eseguirlo manualmente, segui le istruzioni riportate di seguito:

## Configurazione dei ruoli IAM per MCP Server
<a name="iam-role-mcp-server"></a>

Per accedere al server SMUS Managed MCP, è necessario un ruolo IAM con la seguente politica in linea:

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowUseSagemakerUnifiedStudioMcpServer",
            "Effect": "Allow",
            "Action": [
                "sagemaker-unified-studio-mcp:InvokeMcp",
                "sagemaker-unified-studio-mcp:CallReadOnlyTool",
                "sagemaker-unified-studio-mcp:CallPrivilegedTool"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}
```

Nei passaggi successivi, creeremo un profilo per questo ruolo. L'account che assume questo ruolo per ottenere le credenziali deve essere aggiunto alla politica di assunzione del ruolo.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowAccountToAssumeRole",
      "Effect": "Allow",
      "Principal": { "AWS": "arn:aws:iam::<accountId>:root" },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

## Autorizzazioni aggiuntive per modalità di distribuzione (EMR-EC2/EMR-S/Glue)
<a name="additional-permissions"></a>

### Applicazioni EMR-EC2
<a name="emr-ec2-permissions"></a>

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "EMREC2ReadAccess",
            "Effect": "Allow",
            "Action": [
                "elasticmapreduce:DescribeCluster",
                "elasticmapreduce:DescribeStep",
                "elasticmapreduce:ListSteps",
                "elasticmapreduce:ListClusters",
                "elasticmapreduce:DescribeJobFlows"
            ],
            "Resource": [
                "*"
            ]
        },
        {
            "Sid": "EMRS3LogAccess",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": "*"
        },
        {
            "Sid": "EMRPersistentApp",
            "Effect": "Allow",
            "Action": [
                "elasticmapreduce:CreatePersistentAppUI",
                "elasticmapreduce:DescribePersistentAppUI",
                "elasticmapreduce:GetPersistentAppUIPresignedURL"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}
```

### Glue Jobs
<a name="glue-permissions"></a>

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "GlueReadAccess",
            "Effect": "Allow",
            "Action": [
                "glue:GetJob",
                "glue:GetJobRun",
                "glue:GetJobRuns",
                "glue:GetJobs",
                "glue:BatchGetJobs"
            ],
            "Resource": [
                "arn:aws:glue:*:<account id>:job/*"
            ]
        },
        {
            "Sid": "GlueCloudWatchLogsAccess",
            "Effect": "Allow",
            "Action": [
                "logs:GetLogEvents",
                "logs:FilterLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:*:<account id>:log-group:/aws/glue/*"
            ]
        },
        {
            "Sid": "GlueSparkWebUI",
            "Effect": "Allow",
            "Action": [
                "glue:RequestLogParsing",
                "glue:GetLogParsingStatus",
                "glue:GetEnvironment",
                "glue:GetStage",
                "glue:GetStages",
                "glue:GetStageFiles",
                "glue:BatchGetStageFiles",
                "glue:GetStageAttempt",
                "glue:GetStageAttemptTaskList",
                "glue:GetStageAttemptTaskSummary",
                "glue:GetExecutors",
                "glue:GetExecutorsThreads",
                "glue:GetStorage",
                "glue:GetStorageUnit",
                "glue:GetQueries",
                "glue:GetQuery",
                "glue:GetDashboardUrl"
            ],
            "Resource": [
                "arn:aws:glue:*:<account id>:job/*"
            ]
        },
        {
            "Sid": "GluePassRoleAccess",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "*",
            "Condition": {
                "StringLike": {
                    "iam:PassedToService": "glue.amazonaws.com"
                }
            }
        }
    ]
}
```

### Applicazioni serverless EMR
<a name="emr-serverless-permissions"></a>

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "EMRServerlessReadAccess",
            "Effect": "Allow",
            "Action": [
                "emr-serverless:GetJobRun",
                "emr-serverless:GetApplication",
                "emr-serverless:ListApplications",
                "emr-serverless:ListJobRuns",
                "emr-serverless:ListJobRunAttempts",
                "emr-serverless:GetDashboardForJobRun",
                "emr-serverless:ListTagsForResource"
            ],
            "Resource": [
                "*"
            ]
        },
        {
            "Sid": "EMRServerlessCloudWatchLogsAccess",
            "Effect": "Allow",
            "Action": [
                "logs:GetLogEvents",
                "logs:FilterLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:*:<account id>:log-group:/aws/emr-serverless/*"
            ]
        },
        {
            "Sid": "EMRServerlessS3LogsAccess",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": "*"
        }
    ]
}
```

### Autorizzazioni KMS - Registri CloudWatch
<a name="kms-permissions"></a>

Se CloudWatch i log sono crittografati con una CMK, aggiungi la seguente policy in modo che il servizio possa leggere i log delle applicazioni EMR-Serverless.

```
{
    "Effect": "Allow",
    "Action": [
        "kms:Decrypt",
        "kms:DescribeKey"
    ],
    "Resource": "arn:aws:kms:<region>:<account-id>:key/<cw-logs-cmk-id>"
}
```

# Utilizzo degli strumenti di risoluzione dei problemi di Spark
<a name="spark-troubleshooting-agent-using-tools"></a>

## Strumenti di risoluzione dei problemi disponibili
<a name="available-tools"></a>

Il servizio MCP fornisce diversi strumenti per lo Spark Troubleshooting Agent. Gli strumenti principali sono i seguenti:


| Nome dello strumento | Categoria di utensili | Description | 
| --- | --- | --- | 
| analyze\$1spark\$1workload | Analisi della causa principale | Fornisce una risoluzione dettagliata dei problemi dei carichi di lavoro Apache Spark non riusciti | 
| spark\$1code\$1recommendation | Consiglio Code Fix | Fornisce consigli sul codice Apache Spark per i lavori non riusciti | 

# Configurazione degli endpoint VPC dell'interfaccia per SageMaker Amazon Unified Studio MCP
<a name="spark-troubleshooting-agent-vpc-endpoints"></a>

*Puoi stabilire una connessione privata tra il tuo VPC e il servizio MCP di Amazon SageMaker Unified Studio creando un endpoint VPC di interfaccia.* Gli endpoint di interfaccia sono alimentati da [Amazon VPC](https://aws.amazon.com/vpc/), che ti consente di accedere privatamente al server MCP nel tuo VPC senza un gateway Internet, un dispositivo NAT, una connessione VPN o una connessione. Le istanze nel tuo VPC non necessitano di indirizzi IP pubblici per comunicare con il servizio MCP e il traffico tra il tuo VPC e il servizio MCP non esce dalla rete Amazon.

Ogni endpoint di interfaccia è rappresentato da una o più [interfacce di rete elastiche](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) nelle sottoreti VPC. Per ulteriori informazioni, consulta [Interface VPC endpoint](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) nella Amazon *VPC* User Guide.

## Fase 1: creazione di un endpoint VPC di interfaccia per Amazon SageMaker Unified Studio MCP
<a name="create-vpc-endpoint"></a>

Puoi creare un endpoint VPC per il servizio MCP di Amazon SageMaker Unified Studio utilizzando la console Amazon VPC o il. AWS CLI Per ulteriori informazioni, consultare [Creazione di un endpoint di interfaccia](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) nella *Guida per l’utente di Amazon VPC*.

Crea un endpoint VPC per Amazon SageMaker Unified Studio MCP utilizzando il seguente nome di servizio:
+ com.amazonaws. *<aws-region>*. sagemaker-unified-studio-mcp

Se abiliti il DNS privato per l'endpoint, puoi effettuare richieste API ad Amazon SageMaker Unified Studio MCP utilizzando il nome DNS predefinito per la regione, ad esempio, `sagemaker-unified-studio-mcp.us-east-1.api.aws`

Per ulteriori informazioni, consultare [Accesso a un servizio tramite un endpoint di interfaccia](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#access-service-though-endpoint) in *Guida per l'utente di Amazon VPC*.

## Fase 2: Creazione di una policy sugli endpoint VPC per Amazon SageMaker Unified Studio MCP
<a name="create-vpc-endpoint-policy"></a>

Puoi allegare una policy per gli endpoint al tuo endpoint VPC che controlla l'accesso ad SageMaker Amazon Unified Studio MCP. La policy specifica le informazioni riportate di seguito:
+ Il principale che può eseguire operazioni.
+ Le azioni che possono essere eseguite.
+ Le risorse sui cui si possono eseguire operazioni.

Per ulteriori informazioni, consulta [Controllo degli accessi ai servizi con endpoint VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) in *Guida per l'utente di Amazon VPC*.

### Esempio: policy degli endpoint VPC per consentire l'accesso MCP a uno specifico ruolo IAM
<a name="vpc-endpoint-policy-example"></a>

Di seguito è riportato un esempio di policy sugli endpoint per l'accesso MCP ad Amazon SageMaker Unified Studio. Se collegata a un endpoint, questa policy consente l'accesso alle azioni MCP di Amazon SageMaker Unified Studio elencate per uno specifico ruolo principale IAM su tutte le risorse.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::ACCOUNT-ID:role/YourRoleName"
      },
      "Action": [
        "sagemaker-unified-studio-mcp:InvokeMcp",
        "sagemaker-unified-studio-mcp:CallReadOnlyTool",
        "sagemaker-unified-studio-mcp:CallPrivilegedTool"
      ],
      "Resource": "*"
    }
  ]
}
```

## Fase 3: Verifica del tuo VPC
<a name="test-vpc-endpoint"></a>

Il `curl` comando convalida la connettività di end-to-end rete dalla rete VPC (EC2) all'endpoint VPC effettuando una richiesta. HTTP/HTTPS Una risposta curl che riceve un messaggio dal server MCP conferma che il percorso di rete completo è funzionante.

### Metodo 1: con DNS privato abilitato (consigliato)
<a name="test-private-dns-enabled"></a>

```
curl https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-troubleshooting/mcp
```

### Metodo 2: senza DNS privato abilitato
<a name="test-private-dns-disabled"></a>

```
curl -k https://vpce-0069xxxx-ejwhxxx.sagemaker-unified-studio-mcp.us-east-1.vpce.amazonaws.com/spark-troubleshooting/mcp
```

**Nota**  
Il `-k` flag ignora la verifica del certificato SSL a causa della mancata corrispondenza del nome host tra il nome DNS dell'endpoint VPC e il nome comune (CN) del certificato.

In entrambi i casi, il comando curl restituisce una risposta:. `{"Message":"...."}` La restituzione con un messaggio verifica la corretta connettività del percorso di rete all'endpoint VPC del servizio MCP.

## Passaggio 4: Inizia a utilizzare l'endpoint VPC MCP
<a name="use-vpc-endpoint"></a>

Dopo aver verificato la connessione, puoi seguire i passaggi per configurare l'MCP in. [Configurazione dell'agente di risoluzione dei problemi](spark-troubleshooting-agent-setup.md) Usa semplicemente l'endpoint VPC privato nella tua configurazione MCP.

# Elaborazione interregionale per l'agente di risoluzione dei problemi di Apache Spark
<a name="spark-troubleshooting-cross-region-processing"></a>

L'agente di risoluzione dei problemi di Apache Spark utilizza l'inferenza tra regioni per elaborare le richieste in linguaggio naturale e generare risposte. Con l'inferenza interregionale, l'agente indirizza automaticamente la richiesta di inferenza per ottimizzare le prestazioni, massimizzare le risorse di elaborazione disponibili e la disponibilità dei modelli e fornire la migliore esperienza al cliente. Il tipo di inferenza interregionale utilizzata dipende dalla regione in cui viene eseguito l'agente di risoluzione dei problemi di Apache Spark. Nella maggior parte delle regioni, l'agente seleziona la regione ottimale all'interno dell'area geografica per elaborare le richieste di inferenza. Tuttavia, in alcune regioni una richiesta di inferenza effettuata dall'agente viene inoltrata in modo sicuro a tutte le risorse di elaborazione disponibili in tutte le regioni commerciali globali. AWS 

## Inferenza tra regioni
<a name="cross-region-inference-overview"></a>

L'agente di risoluzione dei problemi di Apache Spark è basato su Amazon Bedrock e utilizza l'inferenza tra regioni per distribuire il traffico tra diverse AWS regioni e migliorare le prestazioni e l'affidabilità dell'inferenza del modello di linguaggio di grandi dimensioni (LLM).

Sebbene l'inferenza interregionale non modifichi il luogo in cui è ospitata l'applicazione Spark o l'esperienza di risoluzione dei problemi o dove sono archiviati i dati, le richieste di input e i risultati di output possono essere trasmessi a regioni diverse per l'elaborazione dell'inferenza. Tutti i dati vengono trasmessi crittografati attraverso la rete sicura di Amazon.

Non sono previsti costi aggiuntivi per l'utilizzo dell'inferenza tra regioni.

## Regioni supportate per l'inferenza tra regioni
<a name="supported-regions-cross-region"></a>

 **Regioni che utilizzano l'inferenza geografica tra regioni** 

Per la maggior parte delle regioni, le richieste di inferenza tra regioni vengono conservate all'interno AWS delle regioni che fanno parte della stessa area geografica in cui viene eseguito l'agente di risoluzione dei problemi di Apache Spark. Ad esempio, una richiesta effettuata dall'agente nella regione Stati Uniti orientali (Virginia settentrionale) viene indirizzata solo alle AWS regioni all'interno della geografia degli Stati Uniti. La tabella seguente descrive le regioni verso cui le richieste possono essere indirizzate a seconda dell'area geografica in cui ha avuto origine la richiesta:


| Geografia supportata | Regioni di inferenza | 
| --- | --- | 
|  Stati Uniti  |  Stati Uniti orientali (Virginia settentrionale) (us-east-1), Stati Uniti occidentali (Oregon) (us-west-2), Stati Uniti orientali (Ohio) (us-east-2), Stati Uniti occidentali (California settentrionale) (us-west-1)  | 
|  Europa  |  Europa (Francoforte) (eu-central-1), Europa (Irlanda) (eu-west-1), Europa (Parigi) (eu-west-3), Europa (Stoccolma) (eu-north-1), Europa (Londra) (eu-west-2)  | 
|  Asia Pacifico  |  Asia Pacifico (Tokyo) (ap-northeast-1), Asia Pacifico (Seoul) (ap-northeast-2), Asia Pacifico (Mumbai) (ap-south-1)  | 

### Regioni che utilizzano l'inferenza globale tra regioni
<a name="global-cross-region-inference"></a>

**Importante**  
Le seguenti AWS regioni utilizzano l'inferenza globale tra regioni. Quando si utilizza l'agente di risoluzione dei problemi di Apache Spark in queste regioni, le richieste possono essere trasmesse a livello globale ad altre AWS regioni per l'elaborazione delle inferenze per ottimizzare prestazioni e disponibilità:  
Sud America (San Paolo) (sa-east-1)
Asia Pacifico (Singapore) (ap-southeast-1)
Asia Pacifico (Sydney) (ap-southeast-2)
Canada (Centrale) (ca-central-1)

# Registrazione delle chiamate MCP di Amazon SageMaker Unified Studio tramite AWS CloudTrail
<a name="spark-troubleshooting-cloudtrail-integration"></a>

Amazon SageMaker Unified Studio MCP Server è integrato con AWS CloudTrail un servizio che fornisce una registrazione delle azioni intraprese da un utente, ruolo o AWS servizio in Amazon SageMaker Unified Studio MCP Server. CloudTrail acquisisce tutte le chiamate API per Amazon SageMaker Unified Studio MCP Server come eventi. Le chiamate acquisite includono chiamate a Amazon SageMaker Unified Studio MCP Server e chiamate di codice ad altre AWS operazioni durante l'esecuzione degli strumenti da SageMaker Unified Studio MCP Server. Se crei un trail, puoi abilitare la distribuzione continua di CloudTrail eventi a un bucket Amazon S3, inclusi gli eventi per Amazon SageMaker Unified Studio MCP Server. **Se non configuri un percorso, puoi comunque visualizzare gli eventi più recenti nella CloudTrail console nella cronologia degli eventi.** Utilizzando le informazioni raccolte da CloudTrail, puoi determinare la richiesta effettuata al server MCP di Amazon SageMaker Unified Studio, l'indirizzo IP da cui è stata effettuata la richiesta, chi ha effettuato la richiesta, quando è stata effettuata e dettagli aggiuntivi.

Per ulteriori informazioni CloudTrail, consulta la Guida per l'[AWS CloudTrail utente](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).

## Informazioni sul server MCP di Amazon SageMaker Unified Studio in CloudTrail
<a name="sagemaker-mcp-info-in-cloudtrail"></a>

CloudTrail è abilitato sul tuo AWS account al momento della creazione dell'account. **Quando si verifica un'attività in Amazon SageMaker Unified Studio MCP Server, tale attività viene registrata in un CloudTrail evento insieme ad altri eventi di AWS servizio nella cronologia degli eventi.** Puoi visualizzare, cercare e scaricare eventi recenti nel tuo AWS account. Per ulteriori informazioni, consulta [Visualizzazione degli eventi con la cronologia degli CloudTrail eventi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).

Per una registrazione continua degli eventi nel tuo AWS account, inclusi gli eventi per SageMaker Unified Studio MCP Server, crea una traccia. Un trail consente di CloudTrail inviare file di log a un bucket Amazon S3. Per impostazione predefinita, quando crei un percorso nella console, il percorso si applica a tutte le AWS regioni. Il trail registra gli eventi di tutte le regioni della AWS partizione e consegna i file di log al bucket Amazon S3 specificato. Inoltre, puoi configurare altri AWS servizi per analizzare ulteriormente e agire in base ai dati sugli eventi raccolti nei log. CloudTrail Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Panoramica della creazione di un percorso](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail servizi e integrazioni supportati](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html)
+ [Configurazione delle notifiche Amazon SNS per CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/configure-sns-notifications-for-cloudtrail.html)
+ [Ricezione di file di CloudTrail registro da più regioni](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) e [ricezione di file di CloudTrail registro da](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html) più account

Tutte le chiamate agli strumenti di SageMaker Unified Studio MCP Server e le chiamate API ai AWS servizi durante le esecuzioni dello strumento vengono registrate da. CloudTrail Ad esempio, le chiamate ai diversi strumenti e le chiamate di AWS servizio effettuate dagli strumenti generano voci nei file di registro. CloudTrail 

Ogni evento o voce di log contiene informazioni sull’utente che ha generato la richiesta. Le informazioni di identità consentono di determinare quanto segue:
+ Se la richiesta è stata effettuata con le credenziali dell'utente IAM o root.
+ Se la richiesta è stata effettuata con le credenziali di sicurezza temporanee per un ruolo o un utente federato.
+ Se la richiesta è stata effettuata da un altro AWS servizio.

Per ulteriori informazioni, consulta [Elemento CloudTrail userIdentity](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).

## Informazioni sulle voci dei file di registro di Amazon SageMaker Unified Studio MCP Server
<a name="understanding-mcp-log-entries"></a>

Un trail è una configurazione che consente la distribuzione di eventi come file di log in un bucket Amazon S3 specificato dall'utente. CloudTrail i file di registro contengono una o più voci di registro. Un evento rappresenta una singola richiesta proveniente da qualsiasi fonte e include informazioni sull'azione richiesta, la data e l'ora dell'azione, i parametri della richiesta e così via. CloudTrail i file di registro non sono una traccia ordinata dello stack delle chiamate API pubbliche, quindi non vengono visualizzati in un ordine specifico.

L'esempio seguente mostra una voce di CloudTrail registro che illustra l'`CallTool`azione.

```
{
    "eventVersion": "1.09",
    "userIdentity": {
        ...
    },
    "eventTime": "...",
    "eventSource": "sagemaker-unified-studio-mcp.amazonaws.com",
    "eventName": "CallPrivilegedTool",
    "awsRegion": "us-east-1",
    "sourceIPAddress": "...",
    "userAgent": "...",
    "requestParameters": {
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": "generate_spark_upgrade_plan",
            "arguments": "***",
            "_meta": {
                "progressToken": 1
            }
        },
        "jsonrpc": "2.0"
    },
    "responseElements": {
        "result": {
            "content": "***",
            "structuredContent": "***",
            "isError": false
        },
        "id": 1,
        "jsonrpc": "2.0"
    },
    "requestID": "12345678-1234-1234-1234-123456789012",
    "eventID": "87654321-4321-4321-4321-210987654321",
    "readOnly": false,
    "eventType": "AwsMcpEvent",
    "managementEvent": true,
    "recipientAccountId": "123456789012",
    "eventCategory": "Management"
}
```

L'esempio seguente mostra una voce di CloudTrail registro che dimostra l'`AddJobFlowSteps`azione di Amazon SageMaker Unified Studio MCP durante la chiamata di uno strumento di aggiornamento.

```
{
    "eventVersion": "1.11",
    "userIdentity": {
        "type": "AssumedRole",
        "principalId": "...",
        "arn": "...",
        "accountId": "123456789012",
        "accessKeyId": "...",
        "sessionContext": {
            ...
        },
        "invokedBy": "sagemaker-unified-studio-mcp.amazonaws.com"
    },
    "eventTime": "...",
    "eventSource": "elasticmapreduce.amazonaws.com",
    "eventName": "AddJobFlowSteps",
    "awsRegion": "us-east-1",
    "sourceIPAddress": "sagemaker-unified-studio-mcp.amazonaws.com",
    "userAgent": "sagemaker-unified-studio-mcp.amazonaws.com",
    "requestParameters": {
        "jobFlowId": "j-2PY4KXXXXXX63",
        "steps": [
            ...
        ]
    },
    "responseElements": {
        "stepIds": [
            ...
        ]
    },
    "requestID": "12345678-1234-1234-1234-123456789013",
    "eventID": "87654321-4321-4321-4321-210987654322",
    "readOnly": false,
    "eventType": "AwsApiCall",
    "managementEvent": true,
    "recipientAccountId": "123456789012",
    "sharedEventID": "12345678-1234-1234-1234-123456789012",
    "vpcEndpointId": "sagemaker-unified-studio-mcp.amazonaws.com",
    "vpcEndpointAccountId": "sagemaker-unified-studio-mcp.amazonaws.com",
    "eventCategory": "Management"
}
```

# Miglioramenti del servizio per gli agenti Apache Spark
<a name="spark-agents-service-improvements"></a>

L'agente Apache Spark per Amazon EMR può utilizzare i contenuti, ad esempio, per aiutare l'agente a fornire risposte migliori a domande comuni, risolvere problemi operativi o eseguire il debug.

## Contenuti che possono essere utilizzati per il miglioramento del servizio AWS
<a name="content-used-for-improvement"></a>
+ I tuoi prompt in linguaggio naturale e le risposte generate dagli agenti Apache Spark per Amazon EMR, Glue e Amazon Notebooks AWS SageMaker 

## Contenuti che non vengono utilizzati per il miglioramento del servizio AWS
<a name="content-not-used-for-improvement"></a>
+ Codice scritto da te per le applicazioni Spark
+ SageMaker Contesto e metadati del notebook
+ Dati dal tuo AWS Glue Data Catalog o da altre fonti di dati

Solo i dipendenti di Amazon avranno accesso ai dati. La tua fiducia, la tua privacy e la sicurezza dei contenuti del cliente sono la nostra massima priorità e garantiamo che il nostro utilizzo rispetta i nostri impegni nei tuoi confronti. Per ulteriori informazioni, consulta le Domande frequenti sulla privacy dei dati.

## Come rinunciare
<a name="how-to-opt-out"></a>

Per disattivare la raccolta dei dati per gli agenti Apache Spark, configura una politica di disattivazione dei servizi di intelligenza artificiale in Organizations AWS for Amazon SageMaker Unified Studio MCP Service. Per ulteriori informazioni, consulta le [politiche di disattivazione dei servizi di intelligenza artificiale](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) nella *AWS Organizations User Guide*.

La configurazione di una politica di disattivazione dei servizi AI ha i seguenti effetti:
+ AWS eliminerà i dati raccolti e archiviati per il miglioramento del servizio prima della revoca del consenso (se presente).
+ Dopo l'annullamento, non AWS raccoglieremo o memorizzeremo più questi dati.
+ AWS non utilizzerà più i tuoi contenuti per migliorare il servizio.

# Ottimizzazione delle prestazioni di Spark
<a name="emr-spark-performance"></a>

Amazon EMR offre diverse caratteristiche di ottimizzazione delle prestazioni per Spark. In questo argomento viene descritta in dettaglio ogni caratteristica di ottimizzazione.

Per ulteriori informazioni su come impostare la configurazione Spark, consulta [Configurazione di Spark](emr-spark-configure.md).

## Esecuzione adattiva delle query
<a name="emr-spark-performance-aqe"></a>

L'esecuzione adattiva delle query è un framework per riottimizzare i piani di query in base alle statistiche di runtime. A partire da Amazon EMR 5.30.0, le seguenti ottimizzazioni di esecuzione adattiva delle query di Apache Spark 3 sono disponibili sul runtime Apache Amazon EMR per Spark 2.
+ Conversione adattiva di join
+ Unione adattiva delle partizioni shuffle

**Conversione adattiva di join**

La conversione adattiva dei join migliora le prestazioni delle query convertendo le operazioni in sort-merge-join broadcast-hash-joins operazioni basate sulle dimensioni di runtime delle fasi di query. Broadcast-hash-joinstendono a funzionare meglio quando un lato del join è sufficientemente piccolo da trasmettere in modo efficiente il relativo output a tutti gli executor, evitando così la necessità di mescolare, scambiare e ordinare entrambi i lati del join. La conversione adattiva dei join amplia la gamma di casi in cui Spark funziona automaticamente. broadcast-hash-joins

Questa caratteristica viene attivata per impostazione predefinita. Può essere disabilitata impostando `spark.sql.adaptive.enabled` su `false`, operazione che disabilita anche il framework di esecuzione adattiva delle query. Spark decide di convertire a in sort-merge-join a broadcast-hash-join quando la statistica della dimensione di runtime di uno dei lati di unione non supera`spark.sql.autoBroadcastJoinThreshold`, che per impostazione predefinita è 10.485.760 byte (10 MiB).

**Unione adattiva delle partizioni shuffle**

L'unione adattiva delle partizioni shuffle migliora le prestazioni delle query unendo piccole partizioni shuffle contigue per evitare il sovraccarico dato da un numero eccessivo di attività minori. Ciò consente di configurare un numero più elevato di partizioni shuffle iniziali che poi vengono ridotte in fase di runtime a una dimensione mirata, migliorando le possibilità di avere partizioni shuffle distribuite in modo più uniforme.

Questa funzionalità è attivata per impostazione predefinita, a meno che `spark.sql.shuffle.partitions` non sia impostato in modo esplicito. Può essere abilitata impostando `spark.sql.adaptive.coalescePartitions.enabled` su `true`. Sia il numero iniziale di partizioni shuffle che la dimensione delle partizioni di destinazione possono essere regolati utilizzando rispettivamente le proprietà `spark.sql.adaptive.coalescePartitions.minPartitionNum` e `spark.sql.adaptive.advisoryPartitionSizeInBytes`. Per ulteriori dettagli sulle proprietà Spark correlate a questa caratteristica, consulta la tabella riportata di seguito.


**Proprietà della partizione di unione adattiva Spark**  

| Proprietà | Valore predefinito | Description | 
| --- | --- | --- | 
|  `spark.sql.adaptive.coalescePartitions.enabled`  |  true, a meno che `spark.sql.shuffle.partitions` non sia impostato in modo esplicito  |  Quando true e spark.sql.adaptive.enabled sono impostati su true, Spark unisce le partizioni shuffle contigue in base alla dimensione di destinazione (specificata da `spark.sql.adaptive.advisoryPartitionSizeInBytes`), in modo da evitare l'accumulo di attività minori.  | 
|  `spark.sql.adaptive.advisoryPartitionSizeInBytes`  | 64 MB |  La dimensione degli advisory in byte della partizione shuffle durante l'unione. Questa configurazione ha effetto solo quando `spark.sql.adaptive.enabled` e `spark.sql.adaptive.coalescePartitions.enabled` sono entrambi `true`.  | 
|  `spark.sql.adaptive.coalescePartitions.minPartitionNum`  | 25 |  Il numero minimo di partizioni shuffle dopo l'unione. Questa configurazione ha effetto solo quando `spark.sql.adaptive.enabled` e `spark.sql.adaptive.coalescePartitions.enabled` sono entrambi `true`.  | 
|  `spark.sql.adaptive.coalescePartitions.initialPartitionNum`  | 1000 |  Il numero iniziale di partizioni shuffle prima dell'unione. Questa configurazione ha effetto solo quando `spark.sql.adaptive.enabled` e `spark.sql.adaptive.coalescePartitions.enabled` sono entrambi `true`.  | 

## Eliminazione delle partizioni dinamiche
<a name="emr-spark-performance-dynamic"></a>

L'eliminazione delle partizioni dinamiche migliora le prestazioni del processo selezionando accuratamente partizioni specifiche all'interno di una tabella che devono essere lette ed elaborate per una query specifica. La riduzione della quantità di dati letti ed elaborati determina un risparmio di tempo significativo nell'esecuzione del processo. Questa caratteristica viene attivata per impostazione predefinita con Amazon EMR 5.26.0. Con Amazon EMR 5.24.0 e 5.25.0 puoi abilitare questa caratteristica impostando le proprietà Spark `spark.sql.dynamicPartitionPruning.enabled` da Spark o durante la creazione di cluster. 


**Proprietà della partizione di eliminazione dinamica di partizioni Spark**  

| Proprietà | Valore predefinito | Description | 
| --- | --- | --- | 
|  `spark.sql.dynamicPartitionPruning.enabled`  |  `true`  |  Quando è true, abilitare l'eliminazione dinamica delle partizioni.  | 
|  `spark.sql.optimizer.dynamicPartitionPruning.enforceBroadcastReuse`  |  `true`  |  Quando è `true`, Spark esegue un controllo difensivo prima dell'esecuzione delle query per garantire che il riutilizzo degli scambi broadcast nei filtri di eliminazione dinamica non venga interrotto da regole di preparazione successive, ad esempio regole colonnari definite dall'utente. Quando il riutilizzo è interrotto e questa configurazione è `true`, Spark rimuove i filtri di eliminazione dinamici interessati per evitare problemi di prestazioni e correttezza. I problemi di correttezza possono sorgere quando lo scambio broadcast del filtro di eliminazione dinamica produce risultati diversi e incoerenti dallo scambio broadcast dell'operazione di join corrispondente. L'impostazione di questa configurazione su `false` deve essere eseguita con cautela, in quanto consente di aggirare gli scenari, ad esempio quando il riutilizzo viene interrotto da regole colonnari definite dall'utente. Quando Adaptive Query Execution (Esecuzione adattiva delle query) è abilitata, il riutilizzo broadcast viene sempre applicato.  | 

Questa ottimizzazione migliora le funzionalità esistenti di Spark 2.4.2, che supportano solo la distribuzione dei predicati che possono essere risolti in fase di pianificazione.

Di seguito sono elencati alcuni esempi di distribuzione di predicati statici in Spark 2.4.2.

```
partition_col = 5

partition_col IN (1,3,5)

partition_col between 1 and 3

partition_col = 1 + 3
```

L'eliminazione delle partizioni dinamiche consente al motore Spark di dedurre dinamicamente in fase di runtime quali partizioni devono essere lette e quali possono essere eliminate. Ad esempio, la seguente query comporta due tabelle: la tabella `store_sales` contenente tutte le vendite totali di tutti gli store, partizionata in base alla regione, e la tabella `store_regions` contenente una mappatura di regioni per ogni paese. Le tabelle contengono i dati relativi agli store distribuiti in tutto il mondo, ma vengono eseguite query solo per il Nord America.

```
select ss.quarter, ss.region, ss.store, ss.total_sales 
from store_sales ss, store_regions sr
where ss.region = sr.region and sr.country = 'North America'
```

Senza l'eliminazione delle partizioni dinamiche, questa query leggerà tutte le regioni prima di filtrare il sottoinsieme di regioni che corrispondono ai risultati della subquery. Con l'eliminazione delle partizioni dinamiche, questa query legge ed elabora solo le partizioni per le regioni restituite nella subquery. Questo consente di risparmiare tempo e risorse leggendo meno dati dallo storage ed elaborando meno record.

## Appiattimento delle subquery scalari
<a name="emr-spark-performance-flatten"></a>

Questa ottimizzazione migliora le prestazioni di query che dispongono di subquery scalari sulla stessa tabella. Questa caratteristica viene attivata per impostazione predefinita con Amazon EMR 5.26.0. Con Amazon EMR 5.24.0 e 5.25.0, puoi abilitarla impostando la proprietà Spark `spark.sql.optimizer.flattenScalarSubqueriesWithAggregates.enabled` da Spark o durante la creazione di cluster. Quando questa proprietà è impostata su true, l'ottimizzatore di query appiattisce le subquery scalari accumulate che utilizzano la stessa relazione se possibile. Le subquery scalari vengono appiattite distribuendo gli eventuali predicati presenti nella subquery nelle funzioni di aggregazione e quindi eseguendo una aggregazione, con tutte le funzioni di aggregazione, per relazione.

Di seguito è riportato un esempio di query che sfrutta questa ottimizzazione.

```
select (select avg(age) from students                    /* Subquery 1 */
                 where age between 5 and 10) as group1,
       (select avg(age) from students                    /* Subquery 2 */
                 where age between 10 and 15) as group2,
       (select avg(age) from students                    /* Subquery 3 */
                 where age between 15 and 20) as group3
```

L'ottimizzazione riscrive la query precedente come:

```
select c1 as group1, c2 as group2, c3 as group3
from (select avg (if(age between 5 and 10, age, null)) as c1,
             avg (if(age between 10 and 15, age, null)) as c2,
             avg (if(age between 15 and 20, age, null)) as c3 from students);
```

Nota che la query riscritta legge la tabella studenti una sola volta e i predicati delle tre subquery vengono distribuiti nella funzione `avg`.

## DISTINCT prima di INTERSECT
<a name="emr-spark-performance-distinct"></a>

Questa ottimizzazione ottimizza i join durante l'utilizzo di INTERSECT. Questa caratteristica viene attivata per impostazione predefinita con Amazon EMR 5.26.0. Con Amazon EMR 5.24.0 e 5.25.0, puoi abilitarla impostando la proprietà Spark `spark.sql.optimizer.distinctBeforeIntersect.enabled` da Spark o durante la creazione di cluster. Le query che utilizzano INTERSECT vengono automaticamente convertite per utilizzare un join left-semi. Quando questa proprietà è impostata su true, l'ottimizzatore di query invia l'operatore DISTINCT ai figli di INTERSECT se rileva che l'operatore DISTINCT può far sì che il left-semi join a invece di a. BroadcastHashJoin SortMergeJoin

Di seguito è riportato un esempio di query che sfrutta questa ottimizzazione.

```
(select item.brand brand from store_sales, item
     where store_sales.item_id = item.item_id)
intersect
(select item.brand cs_brand from catalog_sales, item 
     where catalog_sales.item_id = item.item_id)
```

Senza l'abilitazione di questa proprietà `spark.sql.optimizer.distinctBeforeIntersect.enabled`, la query sarà riscritta come segue.

```
select distinct brand from
  (select item.brand brand from store_sales, item
     where store_sales.item_id = item.item_id)
left semi join
   (select item.brand cs_brand from catalog_sales, item 
     where catalog_sales.item_id = item.item_id)
 on brand <=> cs_brand
```

Quando abiliti questa proprietà `spark.sql.optimizer.distinctBeforeIntersect.enabled`, la query sarà riscritta come segue.

```
select brand from
  (select distinct item.brand brand from store_sales, item
     where store_sales.item_id = item.item_id)
left semi join
   (select distinct item.brand cs_brand from catalog_sales, item 
     where catalog_sales.item_id = item.item_id)
 on brand <=> cs_brand
```

## Join del filtro Bloom
<a name="emr-spark-performance-bloom"></a>

Questa ottimizzazione può migliorare le prestazioni di alcuni join mediante il prefiltraggio di un lato di un join utilizzando un filtro [Bloom](https://en.wikipedia.org/wiki/Bloom_filter) generato dal valori dell'altro lato del join. Questa caratteristica viene attivata per impostazione predefinita con Amazon EMR 5.26.0. Con Amazon EMR 5.25.0 puoi abilitare questa caratteristica impostando la proprietà `spark.sql.bloomFilterJoin.enabled` di Spark su `true` da Spark o durante la creazione di cluster.

Di seguito è riportato un esempio di query che può trarre vantaggio da un filtro Bloom.

```
select count(*)
from sales, item
where sales.item_id = item.id
and item.category in (1, 10, 16)
```

Quando questa caratteristica è abilitata, il filtro Bloom viene creato da tutti gli ID degli elementi la cui categoria è presente nel set delle categorie su cui viene eseguita la query. Durante la scansione della tabella SALES, il filtro Bloom viene utilizzato per determinare quali sono le vendite relative a elementi che non sono presenti nel set definito dal filtro Bloom. Pertanto, tali vendite identificate possono essere escluse dal filtro il prima possibile.

## Riordinamento ottimizzato dei join
<a name="emr-spark-performance-join-reorder"></a>

Questa ottimizzazione può migliorare le prestazioni delle query riordinando i join che includono tabelle con filtri. Questa caratteristica viene attivata per impostazione predefinita con Amazon EMR 5.26.0. Con Amazon EMR 5.25.0, è possibile abilitare questa caratteristica impostando il parametro di configurazione Spark `spark.sql.optimizer.sizeBasedJoinReorder.enabled` su "true" (vero). Il comportamento predefinito in Spark è di eseguire il join delle tabelle da sinistra a destra, come elencato nella query. Questa strategia potrebbe non dare l'opportunità di eseguire prima i join più piccoli con i filtri, in modo da trarre vantaggio per join più onerosi in un momento successivo. 

La seguente query di esempio segnala tutti gli elementi restituiti da tutti gli store in un paese. Senza il riordinamento ottimizzato dei join, Spark esegue prima il join delle due tabelle di grandi dimensioni, `store_sales` e `store_returns`, quindi ne esegue il join con `store` e infine con `item`.

```
select ss.item_value, sr.return_date, s.name, i.desc, 
from store_sales ss, store_returns sr, store s, item i
where ss.id = sr.id and ss.store_id = s.id and ss.item_id = i.id
and s.country = 'USA'
```

Con il riordinamento ottimizzato dei join, Spark esegue il join di `store_sales` con `store` per prima cosa poiché `store` ha un filtro ed è inferiore a `store_returns` e a `broadcastable`. Quindi Spark esegue il join con `store_returns` e infine con `item`. Se `item` avesse avuto un filtro e fosse stato trasmissibile, sarebbe stato qualificato per il riordinamento, con il risultato di un join di `store_sales` con `store`, quindi con `item` e infine con `store_returns`.

# Caching dei frammenti dei risultati Spark
<a name="emr-spark-fragment-result-caching"></a>

Amazon EMR 6.6.0 e versioni successive includono la funzionalità opzionale di memorizzazione nella cache di frammenti risultanti di Spark che salva automaticamente nella cache i frammenti dei risultati. Questi frammenti di risultati sono parti dei risultati di sottoalberi di query archiviati in un bucket Amazon S3 di tua scelta. I frammenti dei risultati della query memorizzati vengono riutilizzati nelle successive esecuzioni di query, rilasciando query più veloci.

Result Fragment Caching analizza le query Spark e memorizza nella cache i frammenti di risultati idonei nella posizione S3 specificata. Nelle successive esecuzioni di query, i frammenti dei risultati della query utilizzabili vengono rilevati automaticamente e recuperati da S3. Il Caching dei frammenti di risultato è diverso dal Caching dei set di risultati, in cui le query successive devono corrispondere esattamente alla query originale per restituire risultati dalla cache. Se utilizzato per query che si rivolgono ripetutamente a un sottoinsieme statico di dati, la memorizzazione nella cache dei frammenti di risultato accelera notevolmente le prestazioni.

Si consideri la seguente query, che conta gli ordini fino all'anno 2022:

```
select
    l_returnflag,
    l_linestatus,
    count(*) as count_order
from
    lineitem
where
    l_shipdate <= current_date
    and year(l_shipdate) == '2022'
group by
    l_returnflag,
    l_linestatus
```

Con il passare del tempo, questa query deve essere eseguita ogni giorno per segnalare le vendite totali per l'anno. Senza Caching dei frammenti dei risultati, i risultati per tutti i giorni dell'anno dovranno essere ricalcolati ogni giorno. La query diventerà più lenta nel tempo e sarà più lenta alla fine dell'anno, quando tutti i 365 giorni di risultati dovranno essere ricalcolati.

 Quando si attiva Caching dei frammenti dei risultati, si utilizzano i risultati di tutti i giorni precedenti dell'anno dalla cache. Ogni giorno, la funzione deve ricalcolare solo un giorno di risultati. Dopo che la funzione ha calcolato il frammento del risultato, questa memorizza nella cache il frammento. Di conseguenza, i tempi di query abilitati per la cache sono rapidi e rimangono costanti per ogni query successiva. 

## Abilitazione del Caching dei frammenti dei risultati Spark
<a name="enable-fragment-caching"></a>

Per abilitare la Caching dei frammenti dei risultati di Spark, segui la procedura seguente:

1. Crea un bucket di cache in Amazon S3 e read/write autorizza l'accesso per EMRFS. Per ulteriori informazioni, consulta [Autorizzazione di accesso ai dati di EMRFS in Amazon S3](emr-plan-credentialsprovider.md).

1. Imposta la configurazione di Amazon EMR Spark per abilitare la funzionalità.

   ```
   spark.subResultCache.enabled = true
   spark.subResultCache.fs.root.path = s3://&example-s3-bucket;/cache_dir/
   ```

1. Abilita la gestione del ciclo di vita S3 per il bucket per pulire automaticamente i file della cache.

1. Facoltativamente, configura le maxBufferSize proprietà reductionRationThreshold and per ottimizzare ulteriormente la funzionalità.

   ```
   spark.sql.subResultCache.reductionRatioThreshold
   spark.sql.subResultCache.maxBufferSize
   ```

## Considerazioni su quando utilizzare il Caching dei frammenti
<a name="frag-caching-considerations"></a>

Il risparmio sui costi quando si utilizzano risultati già memorizzati nella cache in Amazon S3 anziché ricalcolarli aumenta con il numero di volte in cui è possibile utilizzare gli stessi risultati memorizzati nella cache. Le query con scansioni di tabelle di grandi dimensioni seguite da filtri o aggregazioni hash che riducono la dimensione del risultato di un fattore di almeno 8 (vale a dire, un rapporto di almeno 8:1 in dimensione di size:results) trarranno i maggiori vantaggi da questa funzione. Maggiore è il rapporto di riduzione tra input e risultati, maggiore è il rapporto costi-benefici. Ne trarranno vantaggio anche le query con rapporti di riduzione inferiori, ma che contengono passaggi di calcolo costosi tra la scansione della tabella e il filtro o le aggregazioni, purché il costo per produrre i risultati sia maggiore del costo per recuperarli da Amazon S3. Per impostazione predefinita, Caching dei frammenti dei risultati ha effetto solo quando rileva che un rapporto di riduzione sarà almeno di 8:1. 

Quando le tue query riutilizzano ripetutamente i risultati memorizzati nella cache, i vantaggi di questa funzione sono maggiori. Le query a finestra continua e incrementali sono buoni esempi. Ad esempio, una query a finestra continua di 30 giorni che è già stata eseguita per 29 giorni, avrebbe solo bisogno di estrarre 1/30 dei dati di destinazione dalla sua origine di input originale e utilizzerebbe frammenti di risultati memorizzati nella cache per i 29 giorni precedenti. Una query a finestra incrementale ne trarrebbe un vantaggio ancora maggiore, poiché l'inizio della finestra rimane fisso: ad ogni invocazione della query, una percentuale minore dell'elaborazione richiederà la lettura dall'origine di input.

Di seguito sono riportate ulteriori considerazioni quando si utilizza il Caching dei frammenti dei risultati:
+ Le query che non hanno come target gli stessi dati con gli stessi frammenti di query avranno una percentuale di riscontri nella cache bassa, quindi non trarranno vantaggio da questa funzione.
+ Le query con rapporti di riduzione bassi che non contengono passaggi di calcolo costosi porteranno a risultati memorizzati nella cache che sono all'incirca tanto costosi da leggere quanto lo erano per l'elaborazione iniziale.
+ La prima query mostrerà sempre una regressione minore a causa del costo di scrittura nella cache.
+ La funzione di memorizzazione nella cache di frammenti risultanti funziona esclusivamente con i file Parquet. Altri formati di file non sono supportati.
+ I buffer della funzione di memorizzazione nella cache di frammenti risultanti tenteranno di memorizzare nella cache solo scansioni con dimensioni di suddivisione dei file pari o superiori a 128 MB. Con la configurazione Spark predefinita, il Caching dei frammenti dei risultati sarà disabilitato se la dimensione di scansione (dimensione totale di tutti i file sottoposti a scansione) divisa per il numero di core esecutori è inferiore a 128 MB. Quando viene impostata una delle configurazioni Spark elencate di seguito, la dimensione della divisione del file sarà:

  ```
  min(maxPartitionBytes, max(openCostInBytes, scan size / minPartitionNum))
  ```
  + spark.sql. leafNodeDefaultParallelismo (il valore predefinito è spark.default.parallelism)
  + file spark.sql. minPartitionNum (il valore predefinito è spark.sql. leafNodeDefaultParallelismo)
  + file spark.sql. openCostInByte
  + file spark.sql. maxPartitionBytes
+ La funzione di memorizzazione nella cache di frammenti risultanti memorizza nella cache la granularità della partizione RDD. Il rapporto di riduzione precedentemente descritto che per impostazione predefinita è 8:1 viene valutato per partizione RDD. I carichi di lavoro con rapporti di riduzione per RDD maggiori o inferiori a 8:1 possono riscontrare vantaggi in termini di prestazioni inferiori rispetto ai carichi di lavoro con rapporti di riduzione per RDD costantemente inferiori a 8:1.
+ La funzione di memorizzazione nella cache di frammenti risultanti utilizza un buffer di scrittura da 16 MB per impostazione predefinita per ogni partizione RDD che viene memorizzata nella cache. Se più di 16 MB verranno memorizzati nella cache per partizione RDD, il costo per determinare l'impossibilità di una scrittura può comportare una regressione delle prestazioni.
+ Mentre, per impostazione predefinita, il Caching dei frammenti dei risultati non tenterà di memorizzare nella cache i risultati della partizione RDD con un rapporto di riduzione inferiore a 8:1 e limiterà il suo buffer di scrittura a 16 MB; entrambi questi valori sono regolabili attraverso le seguenti configurazioni:

  ```
  spark.sql.subResultCache.reductionRatioThreshold (default: 8.0)
  spark.sql.subResultCache.maxBufferSize (default: 16MB, max: 64MB)
  ```
+ Più cluster che utilizzano lo stesso rilascio di Amazon EMR possono condividere la stessa posizione della cache. Per garantire la correttezza dei risultati, la memorizzazione nella cache di frammenti risultanti non utilizzerà i risultati della cache scritti da rilasci differenti di Amazon EMR.
+ La memorizzazione nella cache dei frammenti di risultato verrà disattivata automaticamente per i casi d'uso di Spark Streaming o quando viene RecordServer utilizzato Apache Ranger o. AWS Lake Formation 
+ La cache dei frammenti dei risultati read/writes utilizza i bucket EMRFS/S3A e Amazon S3. È supportata la crittografia CSE (solo con EMRFS) /SSE S3/ SSE KMS. A titolo di contesto, S3A fornisce un'implementazione Hadoop per consentire a un cluster di leggere e scrivere dati da e verso Amazon S3. Nota che il supporto per S3A è disponibile con EMR-7.4.0 e versioni successive.

# Utilizza Nvidia RAPIDS Accelerator per Apache Spark
<a name="emr-spark-rapids"></a>

Con Amazon EMR versioni 6.2.0 e successive, puoi utilizzare il plug-in [RAPIDS Accelerator per Apache Spark](https://docs.nvidia.com/spark-rapids/user-guide/latest/overview.html) di Nvidia per accelerare Spark utilizzando tipi di istanza GPU (Graphics Processing Unit) di EC2. RAPIDS Accelerator esegue l'accelerazione via GPU delle pipeline di data Science di Apache Spark 3.0 senza applicare modifiche al codice e velocizza l'elaborazione dei dati e l'addestramento dei modelli, riducendo notevolmente i costi dell'infrastruttura.

Le sezioni seguenti guidano l'utente nella configurazione del cluster EMR per l'utilizzo del plug-in SPARK-Rapids per Spark.

## Scelta dei tipi di istanza
<a name="emr-spark-rapids-instancetypes"></a>

Per utilizzare il plugin Nvidia Spark-RAPIDS per Spark, i gruppi di istanze principali e attività devono utilizzare i tipi di istanza GPU EC2 che soddisfano i [Requisiti hardware](https://nvidia.github.io/spark-rapids/) di Spark-RAPIDS. Per visualizzare un elenco completo dei tipi di istanza GPU supportati da Amazon EMR, consulta i [Tipi di istanza supportati](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-supported-instance-types.html) nella *Guida alla gestione di Amazon EMR*. Il tipo di istanza per il gruppo di istanze primarie può essere GPU o non GPU, ma i tipi di istanza ARM non sono supportati.

## Impostazione delle configurazioni delle applicazioni per il cluster
<a name="emr-spark-rapids-appconfig"></a>

**1. Abilitare Amazon EMR per installare i plug-in nel nuovo cluster**

Per installare i plug-in, è necessaria la seguente configurazione durante la creazione del cluster:

```
{
	"Classification":"spark",
	"Properties":{
		"enableSparkRapids":"true"
	}
}
```

**2. Configurazione di YARN per utilizzare la GPU**

Per ulteriori informazioni sull'utilizzo della GPU su YARN, consulta [Utilizzo della GPU su YARN](https://hadoop.apache.org/docs/r3.2.1/hadoop-yarn/hadoop-yarn-site/UsingGpus.html) nella documentazione di Apache Hadoop. I seguenti esempi mostrano configurazioni YARN di esempio per le versioni di Amazon EMR 6.x e 7.x:

------
#### [ Amazon EMR 7.x ]

**Esempio di configurazione YARN per Amazon EMR 7.x**

```
{
    "Classification":"yarn-site",
    "Properties":{
        "yarn.nodemanager.resource-plugins":"yarn.io/gpu",
        "yarn.resource-types":"yarn.io/gpu",
        "yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
        "yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
        "yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
        "yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/spark-rapids-cgroup",
        "yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
        "yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
    }
},{
    "Classification":"container-executor",
    "Properties":{
        
    },
    "Configurations":[
        {
            "Classification":"gpu",
            "Properties":{
                "module.enabled":"true"
            }
        },
        {
            "Classification":"cgroups",
            "Properties":{
                "root":"/spark-rapids-cgroup",
                "yarn-hierarchy":"yarn"
            }
        }
    ]
}
```

------
#### [ Amazon EMR 6.x ]

**Esempio di configurazione YARN per Amazon EMR 6.x**

```
{
    "Classification":"yarn-site",
    "Properties":{
        "yarn.nodemanager.resource-plugins":"yarn.io/gpu",
        "yarn.resource-types":"yarn.io/gpu",
        "yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
        "yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
        "yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
        "yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/sys/fs/cgroup",
        "yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
        "yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
    }
},{
    "Classification":"container-executor",
    "Properties":{
        
    },
    "Configurations":[
        {
            "Classification":"gpu",
            "Properties":{
                "module.enabled":"true"
            }
        },
        {
            "Classification":"cgroups",
            "Properties":{
                "root":"/sys/fs/cgroup",
                "yarn-hierarchy":"yarn"
            }
        }
    ]
}
```

------

**3. Configurazione di Spark per utilizzare RAPIDS**

Seguono le configurazioni necessarie per consentire a Spark di utilizzare il plug-in RAPIDS:

```
{
	"Classification":"spark-defaults",
	"Properties":{
		"spark.plugins":"com.nvidia.spark.SQLPlugin",
		"spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh",
		"spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native"
	}
}
```

XGBoost4La [libreria J-Spark](https://xgboost.readthedocs.io/en/latest/jvm/xgboost4j_spark_tutorial.html) nella XGBoost documentazione è disponibile anche quando il plugin Spark RAPIDS è abilitato sul cluster. Puoi utilizzare la seguente configurazione per l'integrazione XGBoost con il tuo job Spark:

```
{
	"Classification":"spark-defaults",
	"Properties":{
		"spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar"
	}
}
```

Per ulteriori configurazioni Spark che è possibile utilizzare per regolare un cluster EMR accelerato da GPU, fai riferimento alla [Rapids Accelerator for Apache Spark tuning guide (Guida alla regolazione dell'Accelerator Rapids per Apache Spark)](https://docs.nvidia.com/spark-rapids/user-guide/latest/tuning-guide.html) nella documentazione di Nvidia.github.io.

**4. Configurazione del pianificatore di capacità YARN**

`DominantResourceCalculator` deve essere configurato per abilitare la pianificazione e l'isolamento della GPU. Per ulteriori informazioni, consulta [Using GPU on YARN (Utilizzo della GPU su YARN)](https://hadoop.apache.org/docs/r3.2.1/hadoop-yarn/hadoop-yarn-site/UsingGpus.html) nella documentazione di Apache Hadoop.

```
{
	"Classification":"capacity-scheduler",
	"Properties":{
		"yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator"
	}
}
```

**5. Creazione di un file JSON per includere tutte le configurazioni**

È possibile creare un file JSON che contiene la configurazione per l'utilizzo del plug-in RAPIDS per il cluster Spark. È possibile fornire il file in un secondo momento all'avvio del cluster.

Il file può essere memorizzato localmente o su S3. Per ulteriori informazioni su come fornire le configurazioni delle applicazioni per i cluster, consulta [Configurazione delle applicazioni](emr-configure-apps.md).

Utilizza i seguenti file di esempio come modelli per creare configurazioni personalizzate.

------
#### [ Amazon EMR 7.x ]

**File `my-configurations.json` di esempio per Amazon EMR 7.x**

```
[
    {
        "Classification":"spark",
        "Properties":{
            "enableSparkRapids":"true"
        }
    },
    {
        "Classification":"yarn-site",
        "Properties":{
            "yarn.nodemanager.resource-plugins":"yarn.io/gpu",
            "yarn.resource-types":"yarn.io/gpu",
            "yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
            "yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
            "yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
            "yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/spark-rapids-cgroup",
            "yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
            "yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
        }
    },
    {
        "Classification":"container-executor",
        "Properties":{
            
        },
        "Configurations":[
            {
                "Classification":"gpu",
                "Properties":{
                    "module.enabled":"true"
                }
            },
            {
                "Classification":"cgroups",
                "Properties":{
                    "root":"/spark-rapids-cgroup",
                    "yarn-hierarchy":"yarn"
                }
            }
        ]
    },
    {
        "Classification":"spark-defaults",
        "Properties":{
            "spark.plugins":"com.nvidia.spark.SQLPlugin",
            "spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh",
            "spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native",
            "spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar",
            "spark.rapids.sql.concurrentGpuTasks":"1",
            "spark.executor.resource.gpu.amount":"1",
            "spark.executor.cores":"2",
            "spark.task.cpus":"1",
            "spark.task.resource.gpu.amount":"0.5",
            "spark.rapids.memory.pinnedPool.size":"0",
            "spark.executor.memoryOverhead":"2G",
            "spark.locality.wait":"0s",
            "spark.sql.shuffle.partitions":"200",
            "spark.sql.files.maxPartitionBytes":"512m"
        }
    },
    {
        "Classification":"capacity-scheduler",
        "Properties":{
            "yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator"
        }
    }
]
```

------
#### [ Amazon EMR 6.x ]

**File `my-configurations.json` di esempio per Amazon EMR 6.x**

```
[
    {
        "Classification":"spark",
        "Properties":{
            "enableSparkRapids":"true"
        }
    },
    {
        "Classification":"yarn-site",
        "Properties":{
            "yarn.nodemanager.resource-plugins":"yarn.io/gpu",
            "yarn.resource-types":"yarn.io/gpu",
            "yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
            "yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
            "yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
            "yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/sys/fs/cgroup",
            "yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
            "yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
        }
    },
    {
        "Classification":"container-executor",
        "Properties":{
            
        },
        "Configurations":[
            {
                "Classification":"gpu",
                "Properties":{
                    "module.enabled":"true"
                }
            },
            {
                "Classification":"cgroups",
                "Properties":{
                    "root":"/sys/fs/cgroup",
                    "yarn-hierarchy":"yarn"
                }
            }
        ]
    },
    {
        "Classification":"spark-defaults",
        "Properties":{
            "spark.plugins":"com.nvidia.spark.SQLPlugin",
            "spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh",
            "spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native",
            "spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar",
            "spark.rapids.sql.concurrentGpuTasks":"1",
            "spark.executor.resource.gpu.amount":"1",
            "spark.executor.cores":"2",
            "spark.task.cpus":"1",
            "spark.task.resource.gpu.amount":"0.5",
            "spark.rapids.memory.pinnedPool.size":"0",
            "spark.executor.memoryOverhead":"2G",
            "spark.locality.wait":"0s",
            "spark.sql.shuffle.partitions":"200",
            "spark.sql.files.maxPartitionBytes":"512m"
        }
    },
    {
        "Classification":"capacity-scheduler",
        "Properties":{
            "yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator"
        }
    }
]
```

------

## Aggiunta di un'operazione di bootstrap per il cluster
<a name="emr-spark-rapids-bootstrap"></a>

Per ulteriori informazioni su come fornire script di un'operazione di bootstrap durante la creazione del cluster, consulta [Nozioni di base sulle operazioni di bootstrap](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-bootstrap.html#bootstrapUses) nella *Guida alla gestione di Amazon EMR*.

I seguenti script di esempio mostrano come creare un file di un'operazione di bootstrap per Amazon EMR 6.x e 7.x:

------
#### [ Amazon EMR 7.x ]

**File `my-bootstrap-action.sh` di esempio per Amazon EMR 7.x**

Per utilizzare YARN per gestire le risorse GPU con le versioni di Amazon EMR 7.x, devi montarlo manualmente sul cluster CGroup v1. Puoi farlo con lo script di un'operazione di bootstrap, come mostrato in questo esempio.

```
#!/bin/bash
set -ex
 
sudo mkdir -p /spark-rapids-cgroup/devices
sudo mount -t cgroup -o devices cgroupv1-devices /spark-rapids-cgroup/devices
sudo chmod a+rwx -R /spark-rapids-cgroup
```

------
#### [ Amazon EMR 6.x ]

**File `my-bootstrap-action.sh` di esempio per Amazon EMR 6.x**

Per le versioni di Amazon EMR 6.x, devi aprire le autorizzazioni CGroup per YARN sul tuo cluster. Puoi farlo con lo script di un'operazione di bootstrap, come mostrato in questo esempio.

```
#!/bin/bash
set -ex
 
sudo chmod a+rwx -R /sys/fs/cgroup/cpu,cpuacct
sudo chmod a+rwx -R /sys/fs/cgroup/devices
```

------

## Avvio del cluster
<a name="emr-spark-rapids-launchcluster"></a>

L'ultimo passaggio consiste nell'avviare il cluster con le configurazioni del cluster menzionate sopra. Segue un esempio del comando per avviare un cluster tramite la CLI Amazon EMR:

```
 aws emr create-cluster \
--release-label emr-7.12.0 \
--applications Name=Hadoop Name=Spark \
--service-role EMR_DefaultRole_V2 \
--ec2-attributes KeyName=my-key-pair,InstanceProfile=EMR_EC2_DefaultRole \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.4xlarge \                 
                  InstanceGroupType=CORE,InstanceCount=1,InstanceType=g4dn.2xlarge \    
                  InstanceGroupType=TASK,InstanceCount=1,InstanceType=g4dn.2xlarge \
--configurations file:///my-configurations.json \
--bootstrap-actions Name='My Spark Rapids Bootstrap action',Path=s3://amzn-s3-demo-bucket/my-bootstrap-action.sh
```

# Accesso alla shell Spark
<a name="emr-spark-shell"></a>

La shell Spark è basata su Scala REPL (Read-Eval-Print-Loop). e consente di creare programmi Spark in modo interattivo e di inviare lavoro al framework. Puoi accedere alla shell (interprete di comandi) Spark tramite connessione al nodo primario con SSH e richiamando `spark-shell`. Per informazioni su come connettersi al nodo primario, consulta la sezione [Connect to the primary node using SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) (Connessione al nodo primario tramite SSH) nella *Guida alla gestione di Amazon EMR*. Gli esempi seguenti utilizzano i log di accesso di Apache HTTP Server archiviati in Amazon S3.

**Nota**  
Il bucket utilizzato in questi esempi è disponibile per i client che possono accedere alla regione Stati Uniti orientali (Virginia settentrionale).

 Per impostazione predefinita, la shell Spark crea il proprio [SparkContext](https://spark.apache.org/docs/1.3.1/api/scala/index.html#org.apache.spark.SparkContext)oggetto chiamato`sc`. È possibile utilizzare questo contesto se è richiesto all'interno del REPL. sqlContextè disponibile anche nella shell ed è un [HiveContext](https://spark.apache.org/docs/latest/api/scala/index.html#org.apache.spark.sql.hive.HiveContext). 

**Example Utilizzare la shell Spark per conteggiare le occorrenze di una stringa in un file archiviato in Amazon S3**  
In questo esempio viene utilizzato `sc` per leggere un file di testo archiviato in Amazon S3.  

```
scala> sc
res0: org.apache.spark.SparkContext = org.apache.spark.SparkContext@404721db

scala> val textFile = sc.textFile("s3://elasticmapreduce/samples/hive-ads/tables/impressions/dt=2009-04-13-08-05/ec2-0-51-75-39.amazon.com.rproxy.govskope.us-2009-04-13-08-05.log")
```
Spark crea il textFile e la [struttura di dati](https://spark.apache.org/docs/latest/programming-guide.html#resilient-distributed-datasets-rdds) associata. Successivamente, l'esempio conteggia il numero di righe nel file di log con la stringa "cartoonnetwork.com":  

```
scala> val linesWithCartoonNetwork = textFile.filter(line => line.contains("cartoonnetwork.com")).count()
linesWithCartoonNetwork: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[2] at filter at <console>:23
<snip>
<Spark program runs>
scala> linesWithCartoonNetwork
res2: Long = 9
```

**Example Utilizzare la shell Spark basata su Python per conteggiare le occorrenze di una stringa in un file archiviato in Amazon S3**  
Spark include anche una shell basata su Python, `pyspark`, che puoi utilizzare per realizzare prototipi di programmi Spark scritti in Python. Proprio come con`spark-shell`, invoca `pyspark` sul nodo primario; anche questo ha lo stesso [SparkContext](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkContext.html#pyspark.SparkContext)oggetto.   

```
>>> sc
<pyspark.context.SparkContext object at 0x7fe7e659fa50>
>>> textfile = sc.textFile("s3://elasticmapreduce/samples/hive-ads/tables/impressions/dt=2009-04-13-08-05/ec2-0-51-75-39.amazon.com.rproxy.govskope.us-2009-04-13-08-05.log")
```
Spark crea il textFile e la [struttura di dati](https://spark.apache.org/docs/latest/programming-guide.html#resilient-distributed-datasets-rdds) associata. Successivamente, l'esempio conteggia il numero di righe nel file di log con la stringa "cartoonnetwork.com".  

```
>>> linesWithCartoonNetwork = textfile.filter(lambda line: "cartoonnetwork.com" in line).count()
15/06/04 17:12:22 INFO lzo.GPLNativeCodeLoader: Loaded native gpl library from the embedded binaries
15/06/04 17:12:22 INFO lzo.LzoCodec: Successfully loaded & initialized native-lzo library [hadoop-lzo rev EXAMPLE]
15/06/04 17:12:23 INFO fs.EmrFileSystem: Consistency disabled, using com.amazon.ws.emr.hadoop.fs.s3n.S3NativeFileSystem as filesystem implementation
<snip>
<Spark program continues>
>>> linesWithCartoonNetwork
9
```

# Usa Amazon SageMaker Spark per l'apprendimento automatico
<a name="emr-spark-sagemaker"></a>

Quando utilizzi Amazon EMR rilascio 5.11.0 e successivi, il componente `aws-sagemaker-spark-sdk` è installato con Spark. [Questo componente installa Amazon SageMaker Spark e le dipendenze associate per l'integrazione di Spark con Amazon. SageMaker](https://aws.amazon.com/sagemaker/) Tieni presente che il `aws-sagemaker-spark-sdk` componente non è disponibile su Amazon EMR 7.x e versioni successive. Puoi usare Amazon SageMaker Spark per creare pipeline di machine learning (ML) Spark utilizzando Amazon Stages. SageMaker *Per ulteriori informazioni, consulta il [README di Amazon SageMaker Spark](https://github.com/aws/sagemaker-spark/blob/master/README.md) su GitHub e [Using Apache Spark with Amazon SageMaker nella Amazon Developer](https://docs.aws.amazon.com/sagemaker/latest/dg/apache-spark.html) Guide. SageMaker *

# Scrittura di un'applicazione Spark
<a name="emr-spark-application"></a>

Le applicazioni [Spark](https://aws.amazon.com/big-data/what-is-spark/) possono essere scritte in Scala, Java o Python. Vari esempi di applicazioni Spark sono disponibili nell'argomento [Spark examples (Esempi Spark)](https://spark.apache.org/examples.html) nella documentazione di Apache Spark. L'esempio di stima del numero Pi è illustrato di seguito nelle tre applicazioni supportate a livello nativo. Puoi anche visualizzare esempi completi in e su. `$SPARK_HOME/examples` [GitHub](https://github.com/apache/spark/tree/master/examples/src/main) Per ulteriori informazioni su come creare JARs per Spark, consulta l'argomento [Quick start](https://spark.apache.org/docs/latest/quick-start.html) nella documentazione di Apache Spark.

## Scala
<a name="emr-spark-application-scala"></a>

Per evitare problemi di compatibilità con Scala, ti consigliamo di utilizzare le dipendenze Spark per la versione corretta di Scala quando compili un'applicazione Spark per un cluster Amazon EMR. La versione Scala che dovresti utilizzare dipende dalla versione di Spark installata nel tuo cluster. Ad esempio, Amazon EMR rilascio 5.30.1 impiega Spark 2.4.5, che è costruito con Scala 2.11. Se il cluster utilizza Amazon EMR rilascio 5.30.1, utilizza le dipendenze Spark per Scala 2.11. Per ulteriori informazioni sulle versioni di Scala utilizzate da Spark, consulta la [Documentazione di Apache Spark](https://spark.apache.org/documentation.html).

```
package org.apache.spark.examples
import scala.math.random
import org.apache.spark._

/** Computes an approximation to pi */
object SparkPi {
  def main(args: Array[String]) {
    val conf = new SparkConf().setAppName("Spark Pi")
    val spark = new SparkContext(conf)
    val slices = if (args.length > 0) args(0).toInt else 2
    val n = math.min(100000L * slices, Int.MaxValue).toInt // avoid overflow
    val count = spark.parallelize(1 until n, slices).map { i =>
      val x = random * 2 - 1
      val y = random * 2 - 1
      if (x*x + y*y < 1) 1 else 0
    }.reduce(_ + _)
    println("Pi is roughly " + 4.0 * count / n)
    spark.stop()
  }
}
```

## Java
<a name="emr-spark-application-java"></a>

```
package org.apache.spark.examples;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;

import java.util.ArrayList;
import java.util.List;

/** 
 * Computes an approximation to pi
 * Usage: JavaSparkPi [slices]
 */
public final class JavaSparkPi {

  public static void main(String[] args) throws Exception {
    SparkConf sparkConf = new SparkConf().setAppName("JavaSparkPi");
    JavaSparkContext jsc = new JavaSparkContext(sparkConf);

    int slices = (args.length == 1) ? Integer.parseInt(args[0]) : 2;
    int n = 100000 * slices;
    List<Integer> l = new ArrayList<Integer>(n);
    for (int i = 0; i < n; i++) {
      l.add(i);
    }

    JavaRDD<Integer> dataSet = jsc.parallelize(l, slices);

    int count = dataSet.map(new Function<Integer, Integer>() {
      @Override
      public Integer call(Integer integer) {
        double x = Math.random() * 2 - 1;
        double y = Math.random() * 2 - 1;
        return (x * x + y * y < 1) ? 1 : 0;
      }
    }).reduce(new Function2<Integer, Integer, Integer>() {
      @Override
      public Integer call(Integer integer, Integer integer2) {
        return integer + integer2;
      }
    });

    System.out.println("Pi is roughly " + 4.0 * count / n);

    jsc.stop();
  }
}
```

## Python
<a name="emr-spark-application-spark27"></a>

```
import argparse
import logging
from operator import add
from random import random

from pyspark.sql import SparkSession

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")


def calculate_pi(partitions, output_uri):
    """
    Calculates pi by testing a large number of random numbers against a unit circle
    inscribed inside a square. The trials are partitioned so they can be run in
    parallel on cluster instances.

    :param partitions: The number of partitions to use for the calculation.
    :param output_uri: The URI where the output is written, typically an Amazon S3
                       bucket, such as 's3://example-bucket/pi-calc'.
    """

    def calculate_hit(_):
        x = random() * 2 - 1
        y = random() * 2 - 1
        return 1 if x**2 + y**2 < 1 else 0

    tries = 100000 * partitions
    logger.info(
        "Calculating pi with a total of %s tries in %s partitions.", tries, partitions
    )
    with SparkSession.builder.appName("My PyPi").getOrCreate() as spark:
        hits = (
            spark.sparkContext.parallelize(range(tries), partitions)
            .map(calculate_hit)
            .reduce(add)
        )
        pi = 4.0 * hits / tries
        logger.info("%s tries and %s hits gives pi estimate of %s.", tries, hits, pi)
        if output_uri is not None:
            df = spark.createDataFrame([(tries, hits, pi)], ["tries", "hits", "pi"])
            df.write.mode("overwrite").json(output_uri)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--partitions",
        default=2,
        type=int,
        help="The number of parallel partitions to use when calculating pi.",
    )
    parser.add_argument(
        "--output_uri", help="The URI where output is saved, typically an S3 bucket."
    )
    args = parser.parse_args()

    calculate_pi(args.partitions, args.output_uri)
```

# Migliorare le prestazioni di Spark con Amazon S3
<a name="emr-spark-s3-performance"></a>

Amazon EMR offre caratteristiche che aiutano a ottimizzare le prestazioni quando si usa Spark per eseguire query e leggere e scrivere i dati salvati in Amazon S3.

[S3 Select](https://aws.amazon.com/blogs/aws/s3-glacier-select/) può migliorare le prestazioni delle query per i file CSV e JSON in alcune applicazioni mediante il pushdown dell'elaborazione ad Amazon S3.

Il committer ottimizzato per EMRFS S3 è un'alternativa alla [OutputCommitter](https://hadoop.apache.org/docs/current/api/org/apache/hadoop/mapreduce/OutputCommitter.html)classe, che utilizza la funzionalità di caricamento multiparte di EMRFS per migliorare le prestazioni durante la scrittura di file Parquet su Amazon S3 utilizzando Spark e Datasets. DataFrames

**Topics**
+ [Usare S3 Select con Spark per migliorare le prestazioni delle query](emr-spark-s3select.md)
+ [EMR Spark MagicCommitProtocol](emr-spark-magic-commit-protocol.md)
+ [Utilizzare il committer ottimizzato S3 EMRFS](emr-spark-s3-optimized-committer.md)
+ [Utilizzo del protocollo di commit ottimizzato per S3 EMRFS](emr-spark-s3-optimized-commit-protocol.md)
+ [Effettuare nuovi tentativi per le richieste Amazon S3 con EMRFS](emr-spark-emrfs-retry.md)

# Usare S3 Select con Spark per migliorare le prestazioni delle query
<a name="emr-spark-s3select"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Con Amazon EMR rilascio 5.17.0 e successivi, puoi utilizzare [S3 Select](https://aws.amazon.com/blogs/aws/s3-glacier-select/) con Spark su Amazon EMR. *S3 Select* consente alle applicazioni il recupero di un solo sottoinsieme di dati da un oggetto. Per Amazon EMR, l'attività di calcolo di filtro di set di dati di grandi dimensioni per l'elaborazione viene "trasferita" dal cluster ad Amazon S3; in tal modo è possibile migliorare le prestazioni in alcune applicazioni e ridurre la quantità di dati trasferiti tra Amazon EMR e Amazon S3.

S3 Select è supportata con file CSV e JSON che utilizzano i valori `s3selectCSV` e `s3selectJSON` per specificare il formato dei dati. Per maggiori informazioni ed esempi, consulta [Specificare S3 Select nel codice](#emr-spark-s3select-specify).

## S3 Select è adatto alla mia applicazione?
<a name="emr-spark-s3select-apps"></a>

È consigliabile eseguire analisi comparative delle applicazioni con e senza S3 Select per vedere se l'utilizzo di tale caratteristica può risultare idoneo per l'applicazione.

Per determinare se l'applicazione è idonea per l'uso di S3 Select, utilizza le seguenti linee guida:
+ La query filtra più di metà del set di dati originale.
+ La connessione di rete tra Amazon S3 e il cluster Amazon EMR ha una buona velocità di trasferimento e larghezza di banda disponibile. Amazon S3 non comprime le risposte HTTP, pertanto è probabile che le dimensioni della risposta aumentino per file di input compressi.

## Considerazioni e limitazioni
<a name="emr-spark-s3select-considerations"></a>
+ La crittografia lato server con chiavi di crittografia fornite dal cliente (SSE-C) e la crittografia lato client di Amazon S3 non sono supportate. 
+ La proprietà `AllowQuotedRecordDelimiters` non è supportata. Se questa proprietà è specificata, la query ha esito negativo.
+ Sono supportati solo i file CSV e JSON in formato UTF-8. Le CSVs linee multiple non sono supportate.
+ Sono supportati solo i file non compressi o gzip.
+ Le opzioni Spark CSV e JSON quali `nanValue`, `positiveInf`, `negativeInf` e le opzioni relative a record danneggiati (ad esempio, le modalità failfast e dropmalformed) non sono supportate.
+ L'utilizzo di virgole (,) all'interno di decimali non è supportato. Ad esempio, `10,000` non è supportato, mentre è supportato `10000`.
+ I caratteri di commento nell'ultima riga non sono supportati.
+ Le righe vuote alla fine di un file non vengono elaborate.
+ I filtri seguenti non sono trasferiti ad Amazon S3:
  + Funzioni di aggregazione quali `COUNT()` e `SUM()`.
  + Filtri che eseguono il `CAST()` di un attributo. Ad esempio, `CAST(stringColumn as INT) = 1`.
  + Filtri con un attributo che è un oggetto o è complesso. Ad esempio, `intArray[1] = 1, objectColumn.objectNumber = 1`.
  + I filtri per i quali il valore non è un valore letterale. Ad esempio, `intColumn1 = intColumn2`
  + Sono supportati solo [tipi di dati supportati da S3 Select](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-glacier-select-sql-reference-data-types.html) con le limitazioni documentate.

## Specificare S3 Select nel codice
<a name="emr-spark-s3select-specify"></a>

Gli esempi seguenti mostrano come specificare S3 Select per CSV utilizzando Scala, SQL, R e. PySpark È possibile utilizzare S3 Select per JSON nello stesso modo. Per un elenco delle opzioni, dei relativi valori predefiniti e le limitazioni, consulta [Opzioni](#emr-spark-s3select-specify-options).

------
#### [ PySpark ]

```
spark
  .read
  .format("s3selectCSV") // "s3selectJson" for Json
  .schema(...) // optional, but recommended
  .options(...) // optional
  .load("s3://path/to/my/datafiles")
```

------
#### [ R ]

```
read.df("s3://path/to/my/datafiles", "s3selectCSV", schema, header = "true", delimiter = "\t")
```

------
#### [ Scala ]

```
spark
  .read
  .format("s3selectCSV") // "s3selectJson" for Json
  .schema(...) // optional, but recommended
  .options(...) // optional. Examples:  
  // .options(Map("quote" -> "\'", "header" -> "true")) or
  // .option("quote", "\'").option("header", "true")
  .load("s3://path/to/my/datafiles")
```

------
#### [ SQL ]

```
CREATE TEMPORARY VIEW MyView (number INT, name STRING) USING s3selectCSV OPTIONS (path "s3://path/to/my/datafiles", header "true", delimiter "\t")
```

------

### Opzioni
<a name="emr-spark-s3select-specify-options"></a>

Le seguenti opzioni sono disponibili quando si utilizzano `s3selectCSV` e `s3selectJSON`. Se non specificate, verranno utilizzati i valori predefiniti.

#### Opzioni con S3selectCSV
<a name="emr-spark-s3select-specify-options-csv"></a>


| Opzione | Predefinita | Utilizzo | 
| --- | --- | --- | 
|  `compression`  |  `"none"`  |  Indica se viene utilizzata la compressione. `"gzip"` è l'unica impostazione supportata oltre a `"none"`.  | 
|  `delimiter`  |  ","  |  Specifica il delimitatore del campo.  | 
|  `quote`  |  `'\"'`  |  Specifica il carattere virgoletta. La specifica di una stringa vuota non è supportata e genera un errore di XML danneggiato.  | 
|  `escape`  |  `'\\'`  |  Specifica il carattere di escape.  | 
|  `header`  |  `"false"`  |  `"false"` specifica che non è presente alcuna intestazione. `"true"` specifica che nella prima riga è presente un'intestazione. Sono supportate solo le intestazioni nella prima riga e non sono supportate righe vuote prima di un'intestazione.  | 
|  comment  |  `"#"`  |  Specifica il carattere per commenti. Non è possibile disabilitare l'indicatore dei commenti. In altre parole, il valore `\u0000` non è supportato.  | 
|  `nullValue`  |  ""  |    | 

#### Opzioni con S3selectJSON
<a name="emr-spark-s3select-specify-options-json"></a>


| Opzione | Predefinita | Utilizzo | 
| --- | --- | --- | 
|  `compression`  |  `"none"`  |  Indica se viene utilizzata la compressione. `"gzip"` è l'unica impostazione supportata oltre a `"none"`.  | 
|  `multiline`  |  "false"  |  `"false"` specifica che JSON è nel formato `LINES` S3 Select, che significa che ogni riga dei dati di input contiene un singolo oggetto JSON. `"true"` specifica che JSON è nel formato `DOCUMENT` S3 Select, che significa che un oggetto JSON può estendersi su più righe dei dati di input.  | 

# EMR Spark MagicCommitProtocol
<a name="emr-spark-magic-commit-protocol"></a>

A partire da EMR 6.15.0, MagicCommitProtocol diventa l'impostazione predefinita FileCommitProtocol per Spark quando si utilizza il file system S3A.

## MagicCommitProtocol
<a name="magic-commit-protocol"></a>

 MagicCommitProtocol Si tratta di un'implementazione alternativa ottimizzata per [FileCommitProtocol](https://dlcdn.apache.org/spark/docs/2.4.2/api/java/org/apache/spark/internal/io/FileCommitProtocol.html)la scrittura di file con EMR Spark su Amazon S3 quando si utilizza il file system S3A. Questo protocollo mira a migliorare le prestazioni delle applicazioni evitando l'uso di operazioni di ridenominazione in Amazon S3 durante le fasi di job e task commit.

 MagicCommitProtocol È l' FileCommitProtocol implementazione predefinita utilizzata da Spark in esecuzione su Amazon Elastic Map Reduce (EMR) quando viene utilizzato il file system S3A. Utilizza MagicCommitProtocol internamente [MagicV2Committer](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/s3a-magicv2-committer.html) per eseguire le scritture di file su Amazon S3.

Per le operazioni di inserimento statiche, MagicCommitProtocol scrive i file nella posizione di output del lavoro durante la fase di conferimento dell'attività. Al contrario, per le operazioni dinamiche di sovrascrittura degli inserti, i file scritti dai tentativi di operazione vengono visualizzati nella posizione di output del lavoro solo dopo il completamento del lavoro. Ciò si ottiene esportando nuovamente i metadati di commit nel driver Spark durante la chiamata di commit del task.

## Abilitazione MagicCommitProtocol
<a name="enabling-magic-commit-protocol"></a>

 MagicCommitProtocol È abilitato per impostazione predefinita per Spark in esecuzione su Amazon Elastic Map Reduce (EMR) quando si utilizza il file system S3A.

Per utilizzare il file system S3A, puoi:

1. Usa lo schema di file come `s3a://` quando definisci la tabella, la partizione o la directory.

1. Imposta la configurazione `fs.s3.impl=org.apache.hadoop.fs.s3a.S3AFileSystem` in core-site.xml.

## Disabilitazione di MagicCommitProtocol
<a name="disabling-magic-commit-protocol"></a>

1. Puoi `spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol` impostarlo su false codificandolo in a`SparkConf`, passandolo come `--conf` parametro nella shell Spark o `spark-submit` and `spark-sql` tools, oppure in. `conf/spark-defaults.conf` Per ulteriori informazioni, consulta la [configurazione di Spark nella documentazione di Apache Spark](https://spark.apache.org/docs/latest/configuration.html).

   L'esempio seguente mostra come disabilitare MagicCommitProtocol durante l'esecuzione di un comando. `spark-sql`

   ```
   spark-sql \
     --conf spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol=false \
   -e "INSERT OVERWRITE TABLE target_table SELECT * FROM source_table;"
   ```

1. Utilizzate la classificazione di `spark-defaults` configurazione per impostare la `spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol` proprietà su false. Per ulteriori informazioni, consulta la sezione [Configurazione delle applicazioni](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html).

## MagicCommitProtocol considerazioni
<a name="magic-commit-considerations"></a>
+ Per l'inserimento di partizioni statiche, negli esecutori Spark, MagicCommitProtocol consuma una piccola quantità di memoria per ogni file scritto da un tentativo di operazione fino a quando l'operazione non viene completata o interrotta. Nella maggior parte dei processi la quantità di memoria consumata è trascurabile. Il driver Spark non richiede memoria aggiuntiva
+ Per l'inserimento dinamico delle partizioni, sui driver Spark, è MagicCommitProtocol necessaria memoria per archiviare le informazioni sui metadati di ogni file salvato fino al completamento o all'interruzione del lavoro. Nella maggior parte dei processi, l'impostazione predefinita della memoria del driver Spark è trascurabile.

  Per i processi che presentano attività di lunga esecuzione che scrivono un numero elevato di file, la memoria che il protocollo di commit consuma può essere notevole e rende necessario adeguare la memoria allocata per Spark, specialmente per gli esecutori Spark. È possibile regolare la memoria utilizzando la proprietà `spark.driver.memory` per i driver Spark e la proprietà `spark.executor.memory` per gli esecutori Spark. Come linea guida, una singola operazione di scrittura di 100.000 file richiederebbe in genere 200 MB di memoria aggiuntivi. Per ulteriori informazioni, consulta le [Proprietà delle applicazioni](https://spark.apache.org/docs/latest/configuration.html#application-properties) nella documentazione relativa alla configurazione di Apache Spark.

# Utilizzare il committer ottimizzato S3 EMRFS
<a name="emr-spark-s3-optimized-committer"></a>

Il committer ottimizzato per EMRFS S3 è un'[OutputCommitter](https://hadoop.apache.org/docs/current/api/org/apache/hadoop/mapreduce/OutputCommitter.html)implementazione alternativa ottimizzata per la scrittura di file su Amazon S3 quando si utilizza EMRFS. Il committer ottimizzato per S3 EMRFS migliora le prestazioni delle applicazioni evitando l'esecuzione di operazioni di elenchi e di ridenominazione in Amazon S3 durante le fasi di commit di processi e attività. Il committer è disponibile in Amazon EMR rilascio 5.19.0 e successivi ed è abilitato per impostazione predefinita in Amazon EMR rilascio 5.20.0 e successivi. Il committer viene utilizzato per i job Spark che utilizzano Spark o Datasets. DataFrames A partire da Amazon EMR 6.4.0, questo committer può essere utilizzato per tutti i formati comuni, tra cui Parquet, ORC e formati testuali (inclusi CSV e JSON). Per i rilasci precedenti ad Amazon EMR 6.4.0, è supportato solo il formato Parquet. Vi sono circostanze in cui il committer non viene utilizzato. Per ulteriori informazioni, consulta [Requisiti per il committer ottimizzato S3 EMRFS](emr-spark-committer-reqs.md).

**Topics**
+ [Requisiti per il committer ottimizzato S3 EMRFS](emr-spark-committer-reqs.md)
+ [Committer ottimizzato S3 EMRFS e caricamenti in più parti](emr-spark-committer-multipart.md)
+ [Considerazioni sull'ottimizzazione dei processi](emr-spark-committer-tuning.md)
+ [Abilitare il committer ottimizzato S3 EMRFS per Amazon EMR 5.19.0](emr-spark-committer-enable.md)

# Requisiti per il committer ottimizzato S3 EMRFS
<a name="emr-spark-committer-reqs"></a>

Il committer ottimizzato S3 EMRFS viene utilizzato quando si verificano le condizioni riportate di seguito:
+ Esegui job Spark che utilizzano Spark o Datasets per scrivere file su Amazon S3. DataFrames A partire da Amazon EMR 6.4.0, questo committer può essere utilizzato per tutti i formati comuni, tra cui Parquet, ORC e formati testuali (inclusi CSV e JSON). Per i rilasci precedenti ad Amazon EMR 6.4.0, è supportato solo il formato Parquet.
+ I caricamenti in più parti sono abilitati in Amazon EMR. Questa è l’impostazione predefinita. Per ulteriori informazioni, consulta [Committer ottimizzato S3 EMRFS e caricamenti in più parti](emr-spark-committer-multipart.md). 
+ Viene utilizzato il supporto integrato per i formati di file di Spark. Il supporto integrato per i formati viene utilizzato nelle seguenti circostanze:
  + Per le tabelle Metastore Hive, quando `spark.sql.hive.convertMetastoreParquet` è impostato su `true` per le tabelle Parquet, oppure quando `spark.sql.hive.convertMetastoreOrc` è impostato su `true` per le tabelle Orc con Amazon EMR versioni 6.4.0 o successive. Queste sono le impostazioni predefinite.
  + Quando i processi scrivono in origini dei dati o tabelle di formato di file, ad esempio la tabella di destinazione viene creata con la clausola `USING parquet`. 
  + Quando i processi scrivono tabelle Parquet non partizionate Hive metastore. Il supporto per Parquet integrato di Spark non supporta le tabelle Hive partizionate, che è una limitazione nota. Per ulteriori informazioni, consulta [Hive metastore Parquet table conversion](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#hive-metastore-parquet-table-conversion) nella Apache Spark and Datasets Guide. DataFrames 
+ Le operazioni di processo Spark che scrivono in una posizione di partizione predefinita, ad esempio `${table_location}/k1=v1/k2=v2/`, usano il committer. Il committer non viene utilizzato se un'operazione di processo scrive in una posizione di partizione personalizzata, ad esempio se un percorso di partizione personalizzato è impostato utilizzando il comando `ALTER TABLE SQL`.
+ Devono essere utilizzati i seguenti valori per Spark:
  + La proprietà `spark.sql.parquet.fs.optimized.committer.optimization-enabled` deve essere impostata su `true`. Questa è l'impostazione predefinita con Amazon EMR 5.20.0 e versione successiva. Con Amazon EMR 5.19.0, il valore predefinito è `false`. Per informazioni su come configurare questo valore, consulta [Abilitare il committer ottimizzato S3 EMRFS per Amazon EMR 5.19.0](emr-spark-committer-enable.md).
  + Se si scrive su tabelle metastore Hive non partizionate, sono supportati solo i formati di file Parquet e Orc. `spark.sql.hive.convertMetastoreParquet`deve essere impostato su `true` se si scrive su tabelle metastore di Parquet Hive non partizionate. `spark.sql.hive.convertMetastoreOrc`deve essere impostato su `true` se si scrive su tabelle metastore di Orc Hive non partizionate. Queste sono le impostazioni predefinite.
  + `spark.sql.parquet.output.committer.class` deve essere impostato su `com.amazon.emr.committer.EmrOptimizedSparkSqlParquetOutputCommitter`. Questa è l'impostazione predefinita.
  + `spark.sql.sources.commitProtocolClass` deve essere impostato su `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol` o `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol`. `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol` è l'impostazione predefinita per la serie Amazon EMR 5.x versione 5.30.0 e successive e per la serie Amazon EMR 6.x versione 6.2.0 e successive. `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol` è l'impostazione predefinita per le versioni Amazon EMR precedenti.
  + Se i processi Spark sovrascrivono i set di dati Parquet partizionati con colonne di partizione dinamiche, le opzioni di scrittura `partitionOverwriteMode` e `spark.sql.sources.partitionOverwriteMode` devono essere impostate su `static`. Questa è l'impostazione predefinita.
**Nota**  
L'opzione di scrittura `partitionOverwriteMode` è stata introdotta in Spark 2.4.0. Per Spark versione 2.3.2, incluso con Amazon EMR rilascio 5.19.0, imposta la proprietà `spark.sql.sources.partitionOverwriteMode`. 

## Quando il committer ottimizzato S3 EMRFS non viene utilizzato
<a name="emr-spark-committer-reqs-anti"></a>

In genere, il committer EMRFS ottimizzato per S3 EMRFS non viene utilizzato nelle situazioni riportate di seguito.


****  

| Situazione | Perché il committer non viene utilizzato | 
| --- | --- | 
| Quando si scrive su HDFS | Il committer supporta solo la scrittura su Amazon S3 utilizzando EMRFS. | 
| Quando si utilizza il file system S3A | Il committer supporta solo EMRFS. | 
| Quando utilizzi l'API RDD di Spark MapReduce  | Il committer supporta solo l'utilizzo di SparkSQL o DataFrame Dataset. APIs | 

I seguenti esempi di Scala mostrano altre situazioni che impediscono di utilizzare il committer EMRFS ottimizzato per S3 in tutto (il primo esempio) e in parte (il secondo esempio).

**Example - Modalità di sovrascrittura dinamica delle partizioni**  
Il seguente esempio di Scala indica a Spark di utilizzare un algoritmo di commit diverso, che impedisce l'uso del committer EMRFS ottimizzato per S3. Il codice imposta la proprietà `partitionOverwriteMode` su `dynamic` per sovrascrivere solo le partizioni su cui si stanno scrivendo i dati. Quindi, le colonne delle partizioni dinamiche vengono specificate da `partitionBy` e la modalità scrittura è impostata su `overwrite`.   

```
val dataset = spark.range(0, 10)
  .withColumn("dt", expr("date_sub(current_date(), id)"))

dataset.write.mode("overwrite")
  .option("partitionOverwriteMode", "dynamic")
  .partitionBy("dt")
  .parquet("s3://amzn-s3-demo-bucket1/output")
```
È necessario configurare tutte e tre le impostazioni per evitare l'utilizzo del committer EMRFS ottimizzato per S3. In questo modo, Spark esegue un algoritmo di commit diverso specificato nel protocollo di commit di Spark. Per i rilasci di Amazon EMR serie 5.x precedenti al 5.30.0 e per i rilasci di Amazon EMR serie 6.x precedenti a 6.2.0, il protocollo di commit utilizza la directory di gestione temporanea di Spark, che è una directory temporanea creata nella posizione di output che inizia con `.spark-staging`. L'algoritmo rinomina in modo sequenziale le directory delle partizioni e questo può influire negativamente sulle prestazioni. Per ulteriori informazioni su Amazon EMR rilascio 5.30.0 e successivi e sul rilascio 6.2.0 e successivi, consulta la sezione [Utilizzo del protocollo di commit ottimizzato per S3 EMRFS](emr-spark-s3-optimized-commit-protocol.md).   
L'algoritmo in Spark 2.4.0 segue questi passaggi:  

1. I tentativi di attività scrivono il loro output nelle directory delle partizioni sotto la directory di staging di Spark, ad esempio `${outputLocation}/spark-staging-${jobID}/k1=v1/k2=v2/`.

1. Per ogni partizione scritta, il tentativo di attività tiene traccia dei percorsi di partizione relativi, ad esempio `k1=v1/k2=v2`.

1. Quando un'attività viene completata correttamente, fornisce al driver tutti i relativi percorsi di partizione che ha tracciato.

1. Al termine di tutte le attività, la fase di commit dei lavori raccoglie tutte le directory delle partizioni che i tentativi di attività riusciti hanno scritto nella directory di gestione temporanea di Spark. Spark rinomina in sequenza ciascuna di queste directory nella sua posizione di output finale utilizzando le operazioni di ridenominazione dell'albero delle directory.

1. La directory di gestione temporanea viene eliminata prima del completamento della fase di commit del processo.

**Example - Posizione della partizione personalizzata**  
In questo esempio, il codice Scala viene inserito in due partizioni. Una partizione ha una posizione di partizione personalizzata. L'altra partizione usa il percorso di partizione predefinito. Il committer ottimizzato S3 EMRFS viene utilizzato solo per scrivere l'output dell'attività nella partizione che utilizza la posizione della partizione predefinita.  

```
val table = "dataset"
val location = "s3://bucket/table"
                            
spark.sql(s"""
  CREATE TABLE $table (id bigint, dt date) 
  USING PARQUET PARTITIONED BY (dt) 
  LOCATION '$location'
""")
                            
// Add a partition using a custom location
val customPartitionLocation = "s3://bucket/custom"
spark.sql(s"""
  ALTER TABLE $table ADD PARTITION (dt='2019-01-28') 
  LOCATION '$customPartitionLocation'
""")
                            
// Add another partition using default location
spark.sql(s"ALTER TABLE $table ADD PARTITION (dt='2019-01-29')")
                            
def asDate(text: String) = lit(text).cast("date")
                            
spark.range(0, 10)
  .withColumn("dt",
    when($"id" > 4, asDate("2019-01-28")).otherwise(asDate("2019-01-29")))
  .write.insertInto(table)
```
Il codice Scala crea i seguenti oggetti Amazon S3:  

```
custom/part-00001-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
custom_$folder$
table/_SUCCESS
table/dt=2019-01-29/part-00000-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
table/dt=2019-01-29_$folder$
table_$folder$
```
Quando si scrive nelle partizioni in posizioni personalizzate, Spark utilizza un algoritmo di commit simile all'esempio precedente, che è descritto di seguito. Come nell'esempio precedente, l'algoritmo produce ridenominazioni sequenziali che possono influire negativamente sulle prestazioni.  

1. Quando si scrive l'output in una partizione in una posizione personalizzata, le attività scrivono in un file nella directory di gestione temporanea di Spark, che viene creata nella posizione di output finale. Il nome del file include un UUID casuale per proteggere il file de collisioni. Il tentativo di attività tiene traccia di ogni file insieme al percorso di output finale desiderato.

1. Quando un'attività viene completata correttamente, fornisce al driver i file e i relativi percorsi di output finali desiderati.

1. Al termine di tutte le attività, la fase di commit dei lavori consente di rinominare in sequenza tutti i file scritti per le partizioni in percorsi personalizzati nei relativi percorsi di output finali.

1. La directory di gestione temporanea viene eliminata prima del completamento della fase di commit del processo.

# Committer ottimizzato S3 EMRFS e caricamenti in più parti
<a name="emr-spark-committer-multipart"></a>

Per utilizzare il committer ottimizzato S3 EMRFS, i caricamenti in più parti devono essere abilitati in Amazon EMR. I caricamenti in più parti sono abilitati per impostazione predefinita. È possibile abilitarli nuovamente, se necessario. Per ulteriori informazioni, consulta [Configurazione del caricamento in più parti per Amazon S3](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart) nella *Guida alla gestione di Amazon EMR*. 

Il committer ottimizzato S3 EMRFS utilizza le caratteristiche tipo transazione dei caricamenti in più parti per garantire che i file scritti da tentativi di attività siano visualizzati solo nella posizione di output del processo durante il commit delle attività. Utilizzando caricamenti in più parti in questo modo, il committer migliora le prestazioni del task commit rispetto alla versione 2 dell'algoritmo predefinito. FileOutputCommitter Quando utilizzi il committer ottimizzato S3 EMRFS, ci sono delle differenze chiave rispetto al comportamento tradizionale del caricamento in più parti di cui tenere conto:
+ I caricamenti in più parti vengono sempre eseguiti indipendentemente dalle dimensioni del file. Questo differisce dal comportamento predefinito di EMRFS, dove la proprietà `fs.s3n.multipart.uploads.split.size` controlla le dimensioni del file in cui vengono attivati i caricamenti in più parti.
+ I caricamenti in più parti restano in stato incompleto per un periodo di tempo più lungo fino a quando avviene il commit o l'arresto dell'attività. Questo differisce dal comportamento predefinito di EMRFS dove un caricamento in più parti si competa quando l'attività termina la scrittura in un determinato file.

A causa di queste differenze, se un Executor JVM Spark si arresta in modo anomalo o viene interrotto mentre le attività sono in corso e stanno scrivendo dati in Amazon S3, i caricamenti in più parti hanno più probabilità di restare indietro. Per questo motivo, quando utilizzi il committer ottimizzato S3 EMRFS, assicurati di seguire le best practice per la gestione dei caricamenti in più parti non riusciti. Per ulteriori informazioni, consulta le [best practice](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#emr-bucket-bestpractices) per utilizzare i bucket Amazon S3 nella *Guida alla gestione di Amazon EMR*.

# Considerazioni sull'ottimizzazione dei processi
<a name="emr-spark-committer-tuning"></a>

Il committer ottimizzato S3 EMRFS consuma una piccola quantità di memoria per ogni file scritto da un tentativo di attività fino a quando avviene il commit o l'arresto dell'attività. Nella maggior parte dei processi la quantità di memoria consumata è trascurabile. Per i processi che presentano attività di lunga esecuzione che scrivono un numero elevato di file, la memoria che il committer consuma può essere notevole e richiede l'adeguamento della memoria allocata per gli executor Spark. Puoi ottimizzare la memoria dell'executor mediante la proprietà `spark.executor.memory`. Orientativamente, un'unica attività che scrive 100.000 file in genere richiede ulteriori 100 MB di memoria. Per ulteriori informazioni, consulta le [Proprietà delle applicazioni](https://spark.apache.org/docs/latest/configuration.html#application-properties) nella documentazione relativa alla configurazione di Apache Spark.

# Abilitare il committer ottimizzato S3 EMRFS per Amazon EMR 5.19.0
<a name="emr-spark-committer-enable"></a>

Se usi Amazon EMR 5.19.0, puoi impostare manualmente la proprietà `spark.sql.parquet.fs.optimized.committer.optimization-enabled` su `true` quando crei un cluster o da Spark se stai utilizzando Amazon EMR.

## Abilitare il committer ottimizzato S3 EMRFS al momento della creazione di un cluster
<a name="w2aac62c61c17c13b5"></a>

È possibile utilizzare la classificazione di configurazione `spark-defaults` per impostare la proprietà `spark.sql.parquet.fs.optimized.committer.optimization-enabled` su `true`. Per ulteriori informazioni, consulta [Configurazione delle applicazioni](emr-configure-apps.md).

## Abilitare il committer ottimizzato S3 EMRFS da Spark
<a name="w2aac62c61c17c13b7"></a>

È possibile impostare `spark.sql.parquet.fs.optimized.committer.optimization-enabled` su `true` impostandola come hardcoded in un `SparkConf`, passandola come parametro `--conf` nella shell Spark o come strumenti `spark-submit` e `spark-sql`, o in `conf/spark-defaults.conf`. Per ulteriori informazioni, consulta la sezione relativa alla [Spark configuration (Configurazione Spark)](https://spark.apache.org/docs/latest/configuration.html) nella documentazione di Apache Spark.

L'esempio seguente mostra come abilitare il committer durante l'esecuzione di un comando spark-sql.

```
spark-sql \
  --conf spark.sql.parquet.fs.optimized.committer.optimization-enabled=true \
  -e "INSERT OVERWRITE TABLE target_table SELECT * FROM source_table;"
```

# Utilizzo del protocollo di commit ottimizzato per S3 EMRFS
<a name="emr-spark-s3-optimized-commit-protocol"></a>

Il protocollo di commit ottimizzato per EMRFS S3 è un'[FileCommitProtocol](https://spark.apache.org/docs/2.2.0//api/java/org/apache/spark/internal/io/FileCommitProtocol.html)implementazione alternativa ottimizzata per scrivere file con sovrascrittura dinamica delle partizioni Spark su Amazon S3 quando si utilizza EMRFS. Il protocollo migliora le prestazioni delle applicazioni evitando le operazioni di ridenominazione in Amazon S3 durante la fase di commit del processo di sovrascrittura dinamica delle partizioni di Spark. 

Tieni presente che il committer ottimizzato per [EMRFS S3 migliora anche le prestazioni evitando le operazioni di ridenominazione](emr-spark-s3-optimized-committer.html). Tuttavia, non funziona per i casi di sovrascrittura dinamica delle partizioni, mentre i miglioramenti del protocollo commit riguardano solo i casi di sovrascrittura dinamica delle partizioni.

Il protocollo di commit è disponibile in Amazon EMR rilascio 5.30.0 e successivi ed è abilitato per impostazione predefinita in Amazon EMR rilascio 6.2.0 e successivi. Amazon EMR ha aggiunto un miglioramento del parallelismo a partire dal rilascio 5.31.0. Il protocollo viene utilizzato per i lavori Spark che utilizzano Spark o Datasets. DataFrames Esistono circostanze in cui il protocollo di commit non viene utilizzato. Per ulteriori informazioni, consulta [Requisiti per il protocollo di commit ottimizzato per S3 EMRFS](emr-spark-committer-reqs.md).

**Topics**
+ [Requisiti per il protocollo di commit ottimizzato per S3 EMRFS](emr-spark-commit-protocol-reqs.md)
+ [Protocollo di commit ottimizzato per S3 EMRFS e caricamenti in più parti](emr-spark-commit-protocol-multipart.md)
+ [Considerazioni sull'ottimizzazione dei processi](emr-spark-commit-protocol-tuning.md)

# Requisiti per il protocollo di commit ottimizzato per S3 EMRFS
<a name="emr-spark-commit-protocol-reqs"></a>

Il protocollo di commit ottimizzato per S3 EMRFS viene utilizzato quando si verificano le condizioni riportate di seguito:
+ Si eseguono job Spark che utilizzano Spark o Datasets per sovrascrivere le DataFrames tabelle partizionate.
+ Vengono eseguiti processi Spark la cui modalità di sovrascrittura delle partizioni è `dynamic`.
+ I caricamenti in più parti sono abilitati in Amazon EMR. Questa è l’impostazione predefinita. Per ulteriori informazioni, consulta [Protocollo di commit ottimizzato per S3 EMRFS e caricamenti in più parti](emr-spark-commit-protocol-multipart.md). 
+ La cache del file system per EMRFS è abilitata. Questa è l’impostazione predefinita. Verifica che l'impostazione `fs.s3.impl.disable.cache` sia impostata su `false`. 
+ Viene utilizzato il supporto integrato per le origini dei dati di Spark. Il supporto integrato per le origini dei dati viene utilizzato nelle seguenti circostanze:
  + Quando i processi scrivono su origini dei dati o tabelle integrate.
  + Quando i processi scrivono tabelle Parquet del metastore Hive. Ciò accade quando `spark.sql.hive.convertInsertingPartitionedTable` e `spark.sql.hive.convertMetastoreParquet` sono entrambi impostati su true. Queste sono le impostazioni predefinite.
  + Quando i processi scrivono tabelle ORC del metastore Hive. Ciò accade quando `spark.sql.hive.convertInsertingPartitionedTable` e `spark.sql.hive.convertMetastoreOrc` sono entrambi impostati su `true`. Queste sono le impostazioni predefinite.
+ Le operazioni di processo Spark che scrivono in una posizione di partizione predefinita, ad esempio `${table_location}/k1=v1/k2=v2/`, usano il protocollo di commit. Il protocollo non viene utilizzato se un'operazione di processo scrive in una posizione di partizione personalizzata, ad esempio se un percorso di partizione personalizzato è impostato utilizzando il comando `ALTER TABLE SQL`.
+ Devono essere utilizzati i seguenti valori per Spark:
  + `spark.sql.sources.commitProtocolClass` deve essere impostato su `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol`. Questa è l'impostazione predefinita per Amazon EMR rilascio 5.30.0 e successivi, e rilascio 6.2.0 e successivi. 
  + L'opzione di scrittura `partitionOverwriteMode` o `spark.sql.sources.partitionOverwriteMode` deve essere impostata su `dynamic`. L'impostazione predefinita è `static`.
**Nota**  
L'opzione di scrittura `partitionOverwriteMode` è stata introdotta in Spark 2.4.0. Per Spark versione 2.3.2, incluso con Amazon EMR rilascio 5.19.0, imposta la proprietà `spark.sql.sources.partitionOverwriteMode`. 
  + Se i processi Spark sovrascrivono la tabella Parquet del metastore Hive, `spark.sql.hive.convertMetastoreParquet`, `spark.sql.hive.convertInsertingPartitionedTable` e `spark.sql.hive.convertMetastore.partitionOverwriteMode` devono essere impostati su `true`. Queste sono le impostazioni predefinite. 
  + Se i processi Spark sovrascrivono la tabella ORC del metastore Hive, `spark.sql.hive.convertMetastoreOrc`, `spark.sql.hive.convertInsertingPartitionedTable` e `spark.sql.hive.convertMetastore.partitionOverwriteMode` devono essere impostati su `true`. Queste sono le impostazioni predefinite.

**Example - Modalità di sovrascrittura dinamica delle partizioni**  
In questo esempio di Scala, viene attivata l'ottimizzazione. Innanzitutto, imposta la proprietà `partitionOverwriteMode` su `dynamic`. Questo sovrascrive solo le partizioni in cui stai scrivendo i dati. Quindi, specifichi le colonne delle partizioni dinamiche con `partitionBy` e imposti la modalità scrittura su `overwrite`.  

```
val dataset = spark.range(0, 10)
  .withColumn("dt", expr("date_sub(current_date(), id)"))

dataset.write.mode("overwrite")                 // "overwrite" instead of "insert"
  .option("partitionOverwriteMode", "dynamic")  // "dynamic" instead of "static"  
  .partitionBy("dt")                            // partitioned data instead of unpartitioned data
  .parquet("s3://amzn-s3-demo-bucket1/output")    // "s3://" to use Amazon EMR file system, instead of "s3a://" or "hdfs://"
```

## Quando il protocollo di commit ottimizzato per S3 EMRFS non viene utilizzato
<a name="emr-spark-commit-protocol-reqs-anti"></a>

In genere, il protocollo di commit ottimizzato per EMRFS S3 funziona allo stesso modo del protocollo di commit Spark predefinito open source,. `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol` L'ottimizzazione non si verifica nelle seguenti situazioni.


****  

| Situazione | Perché il protocollo di commit non viene utilizzato | 
| --- | --- | 
| Quando si scrive su HDFS | Il protocollo di commit supporta solo la scrittura su Amazon S3 utilizzando EMRFS. | 
| Quando si utilizza il file system S3A | Il protocollo di commit supporta solo EMRFS. | 
| Quando utilizzi MapReduce la nostra API RDD di Spark | Il protocollo di commit supporta solo l'utilizzo di SparkSQL o DataFrame Dataset. APIs | 
| Quando la sovrascrittura dinamica delle partizioni non viene attivata | Il protocollo di commit ottimizza solo i casi di sovrascrittura dinamica delle partizioni. Per altri casi, consulta la sezione [Utilizzare il committer ottimizzato S3 EMRFS](emr-spark-s3-optimized-committer.md). | 

I seguenti esempi di Scala mostrano altre situazioni che il protocollo di commit ottimizzato per S3 EMRFS delega `SQLHadoopMapReduceCommitProtocol`.

**Example - Modalità di sovrascrittura delle partizioni con posizione della partizione personalizzata**  
In questo esempio, i programmi Scala sovrascrivono due partizioni in modalità di sovrascrittura dinamica delle partizioni. Una partizione ha una posizione di partizione personalizzata. L'altra partizione usa il percorso di partizione predefinito. Il protocollo di commit ottimizzato per S3 EMRFS viene utilizzato solo per scrivere l'output dell'attività nella partizione che utilizza la posizione della partizione predefinita.  

```
val table = "dataset"
val inputView = "tempView"
val location = "s3://bucket/table"
                            
spark.sql(s"""
  CREATE TABLE $table (id bigint, dt date) 
  USING PARQUET PARTITIONED BY (dt) 
  LOCATION '$location'
""")

// Add a partition using a custom location
val customPartitionLocation = "s3://bucket/custom"
spark.sql(s"""
  ALTER TABLE $table ADD PARTITION (dt='2019-01-28') 
  LOCATION '$customPartitionLocation'
""")

// Add another partition using default location
spark.sql(s"ALTER TABLE $table ADD PARTITION (dt='2019-01-29')")

def asDate(text: String) = lit(text).cast("date")   
                       
spark.range(0, 10)
  .withColumn("dt",
    when($"id" > 4, asDate("2019-01-28")).otherwise(asDate("2019-01-29")))
  .createTempView(inputView)
  
// Set partition overwrite mode to 'dynamic'
spark.sql(s"SET spark.sql.sources.partitionOverwriteMode=dynamic")
  
spark.sql(s"INSERT OVERWRITE TABLE $table SELECT * FROM $inputView")
```
Il codice Scala crea i seguenti oggetti Amazon S3:  

```
custom/part-00001-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
custom_$folder$
table/_SUCCESS
table/dt=2019-01-29/part-00000-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
table/dt=2019-01-29_$folder$
table_$folder$
```
La scrittura in posizioni di partizione personalizzate nelle versioni precedenti di Spark può causare la perdita di dati. In questo esempio, la partizione `dt='2019-01-28'` andrebbe persa. Per ulteriori dettagli, consulta [SPARK-35106](https://issues.apache.org/jira/browse/SPARK-35106). Questo problema è stato risolto in Amazon EMR rilascio 5.33.0 e successivi, esclusi i rilasci 6.0.x e 6.1.x.

Quando si scrive nelle partizioni in posizioni personalizzate, Spark utilizza un algoritmo di commit simile all'esempio precedente, che è descritto di seguito. Come nell'esempio precedente, l'algoritmo produce ridenominazioni sequenziali che possono influire negativamente sulle prestazioni.

L'algoritmo in Spark 2.4.0 segue questi passaggi:

1. Quando si scrive l'output in una partizione in una posizione personalizzata, le attività scrivono in un file nella directory di gestione temporanea di Spark, che viene creata nella posizione di output finale. Il nome del file include un UUID casuale per proteggere il file de collisioni. Il tentativo di attività tiene traccia di ogni file insieme al percorso di output finale desiderato.

1. Quando un'attività viene completata correttamente, fornisce al driver i file e i relativi percorsi di output finali desiderati.

1. Al termine di tutte le attività, la fase di commit dei lavori consente di rinominare in sequenza tutti i file scritti per le partizioni in percorsi personalizzati nei relativi percorsi di output finali.

1. La directory di gestione temporanea viene eliminata prima del completamento della fase di commit del processo.

# Protocollo di commit ottimizzato per S3 EMRFS e caricamenti in più parti
<a name="emr-spark-commit-protocol-multipart"></a>

Per utilizzare l'ottimizzazione per la sovrascrittura dinamica delle partizioni nel protocollo di commit ottimizzato per S3 EMRFS, i caricamenti in più parti devono essere abilitati in Amazon EMR. I caricamenti in più parti sono abilitati per impostazione predefinita. È possibile abilitarli nuovamente, se necessario. Per ulteriori informazioni, consulta [Configurazione del caricamento in più parti per Amazon S3](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart) nella *Guida alla gestione di Amazon EMR*. 

Durante la scovrascittura dinamica delle partizioni, il protocollo di commit ottimizzato per S3 EMRFS utilizza le caratteristiche tipo transazione dei caricamenti in più parti per garantire che i file scritti da tentativi di attività siano visualizzati solo nella posizione di output del processo durante il commit del processo. Utilizzando i caricamenti in più parti in questo modo, il protocollo di commit migliora le prestazioni del commit dei processi rispetto al protocollo `SQLHadoopMapReduceCommitProtocol` predefinito. Quando utilizzi il protocollo di commit ottimizzato per S3 EMRFS, esistono delle differenze chiave rispetto al comportamento tradizionale del caricamento in più parti di cui tenere conto:
+ I caricamenti in più parti vengono sempre eseguiti indipendentemente dalle dimensioni del file. Questo differisce dal comportamento predefinito di EMRFS, dove la proprietà `fs.s3n.multipart.uploads.split.size` controlla le dimensioni del file in cui vengono attivati i caricamenti in più parti.
+ I caricamenti in più parti restano in stato incompleto per un periodo di tempo più lungo fino a quando avviene il commit o l'arresto dell'attività. Questo differisce dal comportamento predefinito di EMRFS dove un caricamento in più parti si competa quando l'attività termina la scrittura in un determinato file.

A causa di queste differenze, se un esecutore JVM di Spark si arresta in modo anomalo o viene interrotto mentre le attività sono in corso e stanno scrivendo dati in Amazon S3, oppure un driver JVM di Spark ha un arresto anomalo o viene chiuso in modo forzato mentre è in corso un processo, i caricamenti in più parti hanno più probabilità di restare indietro. Per questo motivo, quando utilizzi il protocollo di commit ottimizzato per S3 EMRFS, assicurati di seguire le best practice per la gestione dei caricamenti in più parti non riusciti. Per ulteriori informazioni, consulta le [best practice](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#emr-bucket-bestpractices) per utilizzare i bucket Amazon S3 nella *Guida alla gestione di Amazon EMR*.

# Considerazioni sull'ottimizzazione dei processi
<a name="emr-spark-commit-protocol-tuning"></a>

Sugli esecutori Spark, il protocollo di commit ottimizzato per S3 EMRFS consuma una piccola quantità di memoria per ogni file scritto da un tentativo di attività fino a quando avviene il commit o l'arresto dell'attività. Nella maggior parte dei processi la quantità di memoria consumata è trascurabile. 

Sui driver Spark, il protocollo di commit ottimizzato per S3 EMRFS richiede memoria per archiviare le informazioni sui metadati di ogni file salvato fino a quando avviene il commit o l'arresto del processo. Nella maggior parte dei processi, l'impostazione predefinita della memoria del driver Spark è trascurabile. 

Per i processi che presentano attività di lunga esecuzione che scrivono un numero elevato di file, la memoria che il protocollo di commit consuma può essere notevole e rende necessario adeguare la memoria allocata per Spark, specialmente per gli esecutori Spark. È possibile regolare la memoria utilizzando la proprietà `spark.driver.memory` per i driver Spark e la proprietà `spark.executor.memory` per gli esecutori Spark. Orientativamente, un'unica attività che scrive 100.000 file in genere richiede ulteriori 100 MB di memoria. Per ulteriori informazioni, consulta le [Proprietà delle applicazioni](https://spark.apache.org/docs/latest/configuration.html#application-properties) nella documentazione relativa alla configurazione di Apache Spark.

# Effettuare nuovi tentativi per le richieste Amazon S3 con EMRFS
<a name="emr-spark-emrfs-retry"></a>

In questo argomento vengono fornite informazioni sulle strategie di nuovi tentativi che è possibile utilizzare quando si effettuano richieste ad Amazon S3 con EMRFS. Quando il tasso di richiesta aumenta, S3 tenta di dimensionarsi per supportare la nuova tariffa. Durante questo processo, S3 può limitare le richieste e restituire un errore `503 Slow Down`. Per migliorare il tasso di successo delle richieste S3, è possibile modificare la strategia di nuovi tentativi impostando le proprietà nella configurazione di `emrfs-site`

È possibile modificare la strategia di nuovi tentativi nei modi seguenti.
+ Aumentare il limite massimo di tentativi per la strategia di nuovi tentativi con backoff esponenziale predefinita.
+ Abilitare e configurare la strategia di nuovi tentativi come aumento additivo - diminuzione moltiplicativa (AIMD). AIMD è supportato per Amazon EMR rilascio 6.4.0 e successivi.

## Usare la strategia di backoff esponenziale predefinita
<a name="emr-spark-emrfs-retry-exponential-backoff"></a>

Per impostazione predefinita, EMRFS utilizza una strategia di backoff esponenziale per effettuare nuovi tentativi per le richieste Amazon S3. Il limite di nuovi tentativi predefinito di EMRFS è pari a 15. Per evitare un errore `503 Slow Down` di S3 è possibile aumentare il limite di nuovi tentativi quando si crea un nuovo cluster, in un cluster in esecuzione o in fase di runtime dell'applicazione.

Per aumentare il limite di nuovi tentativi è necessario modificare il valore di `fs.s3.maxRetries` nella propria configurazione `emrfs-site`. I seguenti set di configurazione di esempio impostano `fs.s3.maxRetries` a un valore personalizzato pari a 30.

```
[
    {
      "Classification": "emrfs-site",
      "Properties": {
        "fs.s3.maxRetries": "30"
      }
    }
]
```

Per ulteriori informazioni sull'utilizzo degli oggetti di configurazione, consulta [Configurazione delle applicazioni](emr-configure-apps.md).

## Usare la strategia di nuovi tentativi dell'AIMD
<a name="emr-spark-emrfs-retry-aimd"></a>

Con Amazon EMR rilascio 6.4.0 e successivi, EMRFS supporta una strategia alternativa di ripetizione basata su un modello di aumento additivo/diminuzione moltiplicativa (AIMD). La strategia di nuovi tentativi AIMD è particolarmente utile quando si lavora con cluster Amazon EMR di grandi dimensioni.

AIMD calcola una frequenza di richiesta personalizzata utilizzando i dati sulle recenti richieste di successo. Questa strategia riduce il numero di richieste limitate e i tentativi totali richiesti per ciascuna richiesta.

Per abilitare la strategia di nuovi tentativi AIMD, è necessario impostare la proprietà `fs.s3.aimd.enabled` su `true` nella configurazione `emrfs-site` come nell'esempio seguente.

```
[
    {
      "Classification": "emrfs-site",
      "Properties": {
        "fs.s3.aimd.enabled": "true"
      }
    }
]
```

Per ulteriori informazioni sull'utilizzo degli oggetti di configurazione, consulta [Configurazione delle applicazioni](emr-configure-apps.md).

## Impostazioni avanzate di nuovi tentativi dell'AIMD
<a name="emr-spark-emrfs-retry-advanced-properties"></a>

È possibile configurare le proprietà elencate nella tabella seguente per perfezionare il comportamento dei nuovi tentativi quando si utilizza la strategia di nuovi tentativi dell'AIMD. Per la maggior parte dei casi d'uso, si consiglia di utilizzare i valori predefiniti.


**Proprietà avanzate della strategia di nuovi tentativi dell'AIMD**  

| Proprietà | Valore predefinito | Description | 
| --- | --- | --- | 
| fs.s3.aimd.increaseIncrement | 0.1 | Controlla la rapidità con cui il tasso di richiesta aumenta quando le richieste consecutive hanno esito positivo. | 
| fs.s3.aimd.reductionFactor | 2 | Controlla la rapidità con cui il tasso di richiesta diminuisce quando Amazon S3 restituisce una risposta 503. Il fattore predefinito di 2 riduce a metà il tasso di richiesta. | 
| fs.s3.aimd.minRate | 0.1 | Imposta il limite inferiore per il tasso di richiesta quando le richieste subiscono una limitazione sostenuta da S3. | 
| fs.s3.aimd.initialRate | 5500 | Imposta il tasso di richiesta iniziale, che cambia in base ai valori specificati per fs.s3.aimd.increaseIncrement e fs.s3.aimd.reductionFactor.La frequenza iniziale viene utilizzata anche per le richieste GET e ridimensionata proporzionalmente (3500/5500) per le richieste PUT. | 
| fs.s3.aimd.adjustWindow | 2 | Controlla la frequenza di adeguamento del tasso di richiesta, misurato in numero di risposte. | 
| fs.s3.aimd.maxAttempts | 100 | Imposta il numero massimo di tentativi di provare una richiesta. | 

# Aggiungi una fase Spark
<a name="emr-spark-submit-step"></a>

Puoi utilizzare le fasi di Amazon EMR per inviare lavoro al framework Spark installato su un cluster EMR. Per ulteriori informazioni, consulta l'argomento [Fasi](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html#emr-overview-data-processing) della Guida alla gestione di Amazon EMR. Nella console e nella CLI, puoi eseguire questa operazione utilizzando una fase dell'applicazione Spark, che esegue automaticamente lo script `spark-submit` come fase. Con l'API, utilizzi una fase per invocare `spark-submit` utilizzando `command-runner.jar`.

Per ulteriori informazioni su come inviare applicazioni a Spark, consulta l'argomento [Submitting applications (Invio di applicazioni)](https://spark.apache.org/docs/latest/submitting-applications.html) nella documentazione di Apache Spark.

**Per inviare una fase Spark mediante la console**

1. [Apri la console Amazon EMR in /emr. https://console.aws.amazon.com](https://console.aws.amazon.com/emr/)

1. In **Cluster List (Elenco cluster)**, scegliere il nome del cluster.

1. Scorrere fino alla sezione **Steps (Fasi)** ed espanderla, quindi scegliere **Add step (Aggiungi fase)**.

1. Nella finestra di dialogo **Add Step (Aggiungi fase)**:
   + Per **Tipo di fase**, scegli **Applicazione Spark**.
   + Per **Name (Nome)**, accettare il nome predefinito (applicazione Spark) o digitare un nuovo nome.
   + Per **Deploy mode (Modalità di distribuzione)**, scegliere la modalità **Client** o **Cluster**. La modalità Client avvia il programma driver nell'istanza primaria del cluster, mentre la modalità Cluster avvia il programma driver nel cluster. Per la modalità client, l'output del log del driver viene visualizzato nei log delle fasi, mentre per la modalità cluster, l'output del log del driver viene visualizzato nei log per il primo container YARN. Per ulteriori informazioni, consulta [Cluster mode overview (Panoramica della modalità cluster)](https://spark.apache.org/docs/latest/cluster-overview.html) nella documentazione di Apache Spark.
   + Specificare le **Spark-submit options (Opzioni Spark-submit)** desiderate. Per ulteriori informazioni sulle opzioni `spark-submit`, consulta [Avvio di applicazioni con spark-submit](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit).
   + Per **Application location (Posizione applicazione)**, specificare il percorso locale o URI di S3 dell'applicazione.
   + Lasciare vuoto il campo **Arguments (Argomenti)**.
   + Per **Action on failure (Operazione in caso di errore)**, accettare l'opzione predefinita, ovvero **Continue (Continua)**.

1. Scegliere **Add (Aggiungi)**. La fase viene visualizzata nella console con lo stato Pending (In attesa). 

1. Durante l'esecuzione della fase, lo stato passa da **Pending (In attesa)** a **Running (In esecuzione)** a **Completed (Completata)**. Per aggiornare lo stato, scegliere l'icona **Refresh (Aggiorna)** sopra la colonna **Actions (Operazioni)**. 

1. I risultati della fase sono visualizzati nella pagina Cluster Details (Dettagli cluster) della console di Amazon EMR accanto alla fase in **Log Files (File di log)** se la caratteristica di registrazione dei log è stata configurata. È eventualmente possibile trovare informazioni sulla fase nel bucket di log configurato all'avvio del cluster. 

**Per inviare lavori a Spark utilizzando il AWS CLI**

Inviare una fase quando si crea il cluster o si utilizza il sottocomando `aws emr add-steps` in un cluster esistente. 

1. Utilizzare `create-cluster` come mostrato nell'esempio seguente.
**Nota**  
I caratteri di continuazione della riga Linux (\$1) sono inclusi per la leggibilità. Possono essere rimossi o utilizzati nei comandi Linux. Per Windows, rimuoverli o sostituirli con un accento circonflesso (^).

   ```
   aws emr create-cluster --name "Add Spark Step Cluster" --release-label emr-7.12.0 --applications Name=Spark \
   --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \
   --steps Type=Spark,Name="Spark Program",ActionOnFailure=CONTINUE,Args=[--class,org.apache.spark.examples.SparkPi,/usr/lib/spark/examples/jars/spark-examples.jar,10] --use-default-roles
   ```

   È anche possibile utilizzare `command-runner.jar` come mostrato nell'esempio seguente.

   ```
   aws emr create-cluster --name "Add Spark Step Cluster" --release-label emr-7.12.0 \
   --applications Name=Spark --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \
   --steps Type=CUSTOM_JAR,Name="Spark Program",Jar="command-runner.jar",ActionOnFailure=CONTINUE,Args=[spark-example,SparkPi,10] --use-default-roles
   ```
**Nota**  
I caratteri di continuazione della riga Linux (\$1) sono inclusi per la leggibilità. Possono essere rimossi o utilizzati nei comandi Linux. Per Windows, rimuoverli o sostituirli con un accento circonflesso (^).

1. In alternativa, aggiungere fasi a un cluster in esecuzione. Utilizza `add-steps`.

   ```
   aws emr add-steps --cluster-id j-2AXXXXXXGAPLF --steps Type=Spark,Name="Spark Program",ActionOnFailure=CONTINUE,Args=[--class,org.apache.spark.examples.SparkPi,/usr/lib/spark/examples/jars/spark-examples.jar,10]
   ```

   È anche possibile utilizzare `command-runner.jar` come mostrato nell'esempio seguente.

   ```
   aws emr add-steps --cluster-id j-2AXXXXXXGAPLF --steps Type=CUSTOM_JAR,Name="Spark Program",Jar="command-runner.jar",ActionOnFailure=CONTINUE,Args=[spark-example,SparkPi,10]
   ```

**Invio di lavoro a Spark mediante il kit SDK per Java**

1. L'esempio seguente mostra come aggiungere una fase a un cluster con Spark utilizzando Java.

   ```
   AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
   AmazonElasticMapReduce emr = new AmazonElasticMapReduceClient(credentials);
    
   StepFactory stepFactory = new StepFactory();
   AmazonElasticMapReduceClient emr = new AmazonElasticMapReduceClient(credentials);
   AddJobFlowStepsRequest req = new AddJobFlowStepsRequest();
   req.withJobFlowId("j-1K48XXXXXXHCB");
   
   List<StepConfig> stepConfigs = new ArrayList<StepConfig>();
   		
   HadoopJarStepConfig sparkStepConf = new HadoopJarStepConfig()
   			.withJar("command-runner.jar")
   			.withArgs("spark-submit","--executor-memory","1g","--class","org.apache.spark.examples.SparkPi","/usr/lib/spark/examples/jars/spark-examples.jar","10");			
   		
   StepConfig sparkStep = new StepConfig()
   			.withName("Spark Step")
   			.withActionOnFailure("CONTINUE")
   			.withHadoopJarStep(sparkStepConf);
   
   stepConfigs.add(sparkStep);
   req.withSteps(stepConfigs);
   AddJobFlowStepsResult result = emr.addJobFlowSteps(req);
   ```

1. Visualizzare i risultati della fase esaminando i log relativi alla stessa. Puoi farlo Console di gestione AWS se hai abilitato la registrazione scegliendo **Steps**, selezionando il tuo passaggio e poi, per **i file di registro**, scegliendo o`stdout`. `stderr` Per visualizzare i log disponibili, scegliere **View Logs (Visualizza log)**.

## Sostituzione delle impostazioni di configurazione predefinite di Spark
<a name="dynamic-configuration"></a>

I valori di configurazione predefiniti di Spark possono essere sostituiti per ogni applicazione. Puoi eseguire questa operazione quando invii applicazioni utilizzando una fase, che in pratica passa opzioni a `spark-submit`. Ad esempio, puoi cambiare la memoria assegnata a un processo esecutore modificando `spark.executor.memory`. In tal caso, devi fornire il parametro `--executor-memory` con un argomento come il seguente:

```
spark-submit --executor-memory 1g --class org.apache.spark.examples.SparkPi /usr/lib/spark/examples/jars/spark-examples.jar 10
```

Nello stesso modo, puoi regolare `--executor-cores` e `--driver-memory`. In una fase, forniresti i seguenti argomenti alla fase:

```
--executor-memory 1g --class org.apache.spark.examples.SparkPi /usr/lib/spark/examples/jars/spark-examples.jar 10
```

Puoi anche regolare impostazioni che possono non avere un parametro integrato utilizzando l'opzione `--conf`. Per ulteriori informazioni su altre impostazioni regolabili, consulta l'argomento [Dynamically loading Spark properties (Caricamento dinamico delle proprietà Spark)](https://spark.apache.org/docs/latest/configuration.html#dynamically-loading-spark-properties) nella documentazione di Apache Spark.

# Visualizzazione della cronologia delle applicazioni Spark
<a name="emr-spark-application-history"></a>

È possibile visualizzare i dettagli dell'interfaccia utente di Spark, dell'applicazione YARN e dell'interfaccia utente di Tez utilizzando la scheda **Application user interfaces (Interfacce utente delle applicazioni)** nella pagina dei dettagli di un cluster nella console. Le interfacce utente (UI) dell'applicazione Amazon EMR facilitano la risoluzione dei problemi e l'analisi dei processi attivi e della cronologia dei processi.

Per ulteriori informazioni, consulta [Visualizzazione della cronologia dell'applicazione](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-cluster-application-history.html) nella *Guida alla gestione di Amazon EMR*.

# Accedi al sito web Spark UIs
<a name="emr-spark-webui"></a>

Puoi visualizzare il web Spark UIs seguendo le procedure per creare un tunnel SSH o creare un proxy nella sezione chiamata [Connect to the cluster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node.html) della Amazon EMR Management Guide e poi accedendo allo YARN per il tuo cluster. ResourceManager Scegliere il collegamento per l'applicazione in **Tracking UI (Monitoraggio IU)**. Se la tua applicazione è in esecuzione, vedi. **ApplicationMaster** Ciò consente di accedere all'interfaccia utente Web dell'applicazione master sulla porta 20888 indipendentemente dalla posizione del driver. Il driver può trovarsi nel nodo primario del cluster se l'esecuzione avviene in modalità client YARN. Se stai eseguendo un'applicazione in modalità cluster YARN, il driver si trova nella ApplicationMaster cartella dell'applicazione sul cluster. Se la tua applicazione è terminata, vedi **Cronologia**, che ti porta al numero di porta dell' HistoryServer interfaccia utente Spark a 18080 del nodo primario del cluster EMR. Ciò vale per le applicazioni già completate. Puoi anche accedere all' HistoryServer interfaccia utente di Spark direttamente all'indirizzo http: //:18080/. *master-public-dns-name*

Con Amazon EMR rilascio 5.25.0 o successivi, puoi accedere all'interfaccia utente del server della cronologia Spark dalla console senza configurare un proxy Web tramite una connessione SSH. Per ulteriori informazioni, consulta [Visualizzazione delle interfacce utente dell'applicazione persistente](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html).

# Utilizzo del connettore Amazon Kinesis Data Streams per lo streaming strutturato Spark
<a name="emr-spark-structured-streaming-kinesis"></a>

Le versioni 7.1.0 e successive di Amazon EMR includono un connettore Amazon Kinesis Data Streams per lo streaming strutturato Spark nell'immagine di rilascio. Con questo connettore, puoi utilizzare Spark su Amazon EMR per elaborare i dati archiviati in Amazon Kinesis Data Streams. Il connettore supporta sia i tipi consumer (throughput condiviso) che `GetRecords` (fan-out avanzato). `SubscribeToShard` Questa integrazione si basa su. [https://github.com/awslabs/spark-sql-kinesis-connector](https://github.com/awslabs/spark-sql-kinesis-connector) Per informazioni dettagliate su come iniziare a utilizzare il connettore, consulta il file [README](https://github.com/awslabs/spark-sql-kinesis-connector/blob/main/README.md).

L'esempio seguente mostra come utilizzare il connettore per avviare un'applicazione Spark con Amazon EMR.

```
spark-submit my_kinesis_streaming_script.py
```

# Utilizzo dell'integrazione di Amazon Redshift per Apache Spark su Amazon EMR
<a name="emr-spark-redshift"></a>

Con Amazon EMR rilascio 6.4.0 e successivi, ogni immagine del rilascio include un connettore tra [Apache Spark](https://aws.amazon.com/emr/features/spark/) e Amazon Redshift. Con questo connettore, è possibile utilizzare facilmente Spark su Amazon EMR per elaborare i dati archiviati in Amazon Redshift. Per i rilasci di Amazon EMR da 6.4.0 a 6.8.0, l'integrazione si basa sul [connettore `spark-redshift` open source](https://github.com/spark-redshift-community/spark-redshift#readme). Per Amazon EMR rilascio 6.9.0 e successivi, l'[integrazione di Amazon Redshift per Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) è passata dalla versione della community a un'integrazione nativa. 

**Topics**
+ [Avvio di un'applicazione Spark utilizzando l'integrazione di Amazon Redshift per Apache Spark](emr-spark-redshift-launch.md)
+ [Autenticazione con l'integrazione di Amazon Redshift per Apache Spark](emr-spark-redshift-auth.md)
+ [Lettura e scrittura da e su Amazon Redshift](emr-spark-redshift-readwrite.md)
+ [Considerazioni e limitazioni relative all'utilizzo del connettore Spark](emr-spark-redshift-considerations.md)

# Avvio di un'applicazione Spark utilizzando l'integrazione di Amazon Redshift per Apache Spark
<a name="emr-spark-redshift-launch"></a>

A partire dalla versione 6.4 alla 6.9 di Amazon EMR, è necessario utilizzare l'opzione `--jars` o `--packages` per specificare quale dei seguenti file JAR si desidera utilizzare. L'opzione `--jars` specifica le dipendenze memorizzate localmente, in HDFS o utilizzando HTTP/S. Per visualizzare altre posizioni dei file supportate dall'opzione `--jars`, consulta la sezione [Advanced Dependency Management](https://spark.apache.org/docs/latest/submitting-applications.html#advanced-dependency-management) (Gestione avanzata delle dipendenze) nella documentazione di Spark. L'opzione `--packages` specifica le dipendenze memorizzate nel repository pubblico Maven. 
+ `spark-redshift.jar`
+ `spark-avro.jar`
+ `RedshiftJDBC.jar`
+ `minimal-json.jar`

Le versioni 6.10.0 e successive di Amazon EMR non richiedono la dipendenza `minimal-json.jar` e installano automaticamente le altre dipendenze su ciascun cluster per impostazione predefinita. Gli esempi seguenti mostrano come avviare un'applicazione Spark con l'integrazione di Amazon Redshift per Apache Spark.

------
#### [ Amazon EMR 6.10.0 \$1 ]

L'esempio seguente mostra come avviare un'applicazione Spark con il connettore `spark-redshift` con le versioni 6.10 e successive di Amazon EMR.

```
spark-submit my_script.py
```

------
#### [ Amazon EMR 6.4.0 - 6.9.x ]

Per avviare un'applicazione Spark con un connettore `spark-redshift` dalla versione 6.4 alla 6.9 di Amazon EMR è necessario utilizzare l'opzione `--jars` o `--packages`, come mostrato nell'esempio seguente. Come vedrai, i percorsi elencati con l'opzione `--jars` sono i percorsi predefiniti per i file JAR.

```
spark-submit \
  --jars /usr/share/aws/redshift/jdbc/RedshiftJDBC.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-redshift.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-avro.jar,/usr/share/aws/redshift/spark-redshift/lib/minimal-json.jar \
  my_script.py
```

------

# Autenticazione con l'integrazione di Amazon Redshift per Apache Spark
<a name="emr-spark-redshift-auth"></a>

## Utilizzo Gestione dei segreti AWS per recuperare le credenziali e connettersi ad Amazon Redshift
<a name="emr-spark-redshift-secrets"></a>

Il seguente esempio di codice mostra come recuperare le credenziali Gestione dei segreti AWS per la connessione a un cluster Amazon Redshift con PySpark l'interfaccia per Apache Spark in Python.

```
from pyspark.sql import SQLContext
import boto3

sc = # existing SparkContext
sql_context = SQLContext(sc)

secretsmanager_client = boto3.client('secretsmanager')
secret_manager_response = secretsmanager_client.get_secret_value(
    SecretId='string',
    VersionId='string',
    VersionStage='string'
)
username = # get username from secret_manager_response
password = # get password from secret_manager_response
url = "jdbc:redshift://redshifthost:5439/database?user=" + username + "&password=" + password

# Read data from a table
df = sql_context.read \
    .format("io.github.spark_redshift_community.spark.redshift") \
    .option("url", url) \
    .option("dbtable", "my_table") \
    .option("tempdir", "s3://path/for/temp/data") \
    .load()
```

## Utilizzo di IAM per recuperare le credenziali ed effettuare la connessione ad Amazon Redshift
<a name="emr-spark-redshift-iam"></a>

È possibile utilizzare il driver JDBC versione 2 fornito da Amazon Redshift per connettersi all'endpoint Amazon Redshift con il connettore Spark. Per utilizzare AWS Identity and Access Management (IAM), [configura l'URL JDBC per utilizzare l'autenticazione](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-iam-credentials-configure-jdbc-odbc.html) IAM. Per connetterti a un cluster Redshift da Amazon EMR, devi autorizzare il tuo ruolo IAM a recuperare credenziali IAM temporanee. Assegna le seguenti autorizzazioni al tuo ruolo IAM in modo che possa recuperare le credenziali ed eseguire operazioni Amazon S3. 
+  [Redshift: GetClusterCredentials](https://docs.aws.amazon.com/redshift/latest/APIReference/API_GetClusterCredentials.html) (per i cluster Amazon Redshift forniti) 
+  [Redshift: DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html) (per i cluster Amazon Redshift forniti) 
+ [Redshift: GetWorkgroup](https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_GetWorkgroup.html) (per gruppi di lavoro Serverless Amazon Redshift)
+  [Redshift: GetCredentials](https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_GetCredentials.html) (per gruppi di lavoro Serverless Amazon Redshift) 
+  [s3: GetBucket](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetBucket.html) 
+  [s3: GetBucketLocation](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLocation.html) 
+  [s3: GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) 
+  [s3: PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) 
+  [s3: GetBucketLifecycleConfiguration](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html) 

Per ulteriori informazioni su `GetClusterCredentials`, consulta [Policy delle risorse per `GetClusterCredentials`](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#redshift-policy-resources.getclustercredentials-resources).

Inoltre, devi assicurarti che Amazon Redshift possa assumere il ruolo IAM durante le operazioni `COPY` e `UNLOAD`.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "sts:AssumeRole"
      ],
      "Resource": "arn:aws:iam::123456789012:role/RedshiftServiceRole",
      "Sid": "AllowSTSAssumerole"
    }
  ]
}
```

------

L'esempio seguente utilizza l'autenticazione IAM tra Spark e Amazon Redshift:

```
from pyspark.sql import SQLContext
import boto3

sc = # existing SparkContext
sql_context = SQLContext(sc)

url = "jdbc:redshift:iam://redshift-host:redshift-port/db-name"
iam_role_arn = "arn:aws:iam::account-id:role/role-name"

# Read data from a table
df = sql_context.read \
    .format("io.github.spark_redshift_community.spark.redshift") \
    .option("url", url) \
    .option("aws_iam_role", iam_role_arn) \
    .option("dbtable", "my_table") \
    .option("tempdir", "s3a://path/for/temp/data") \
    .mode("error") \
    .load()
```

# Lettura e scrittura da e su Amazon Redshift
<a name="emr-spark-redshift-readwrite"></a>

I seguenti esempi di codice consentono PySpark di leggere e scrivere dati di esempio da e verso un database Amazon Redshift con API di origine dati e utilizzando SparkSQL.

------
#### [ Data source API ]

 PySpark Utilizzalo per leggere e scrivere dati di esempio da e verso un database Amazon Redshift con API di origine dati.

```
import boto3
from pyspark.sql import SQLContext

sc = # existing SparkContext
sql_context = SQLContext(sc)

url = "jdbc:redshift:iam://redshifthost:5439/database"
aws_iam_role_arn = "arn:aws:iam::accountID:role/roleName"

df = sql_context.read \
    .format("io.github.spark_redshift_community.spark.redshift") \
    .option("url", url) \
    .option("dbtable", "tableName") \
    .option("tempdir", "s3://path/for/temp/data") \
    .option("aws_iam_role", "aws_iam_role_arn") \
    .load()

df.write \
    .format("io.github.spark_redshift_community.spark.redshift") \
    .option("url", url) \
    .option("dbtable", "tableName_copy") \
    .option("tempdir", "s3://path/for/temp/data") \
    .option("aws_iam_role", "aws_iam_role_arn") \
    .mode("error") \
    .save()
```

------
#### [ SparkSQL ]

 PySpark Utilizzalo per leggere e scrivere dati di esempio da e verso un database Amazon Redshift con SparkSQL.

```
import boto3
import json
import sys
import os
from pyspark.sql import SparkSession

spark = SparkSession \
    .builder \
    .enableHiveSupport() \
    .getOrCreate()
    
url = "jdbc:redshift:iam://redshifthost:5439/database"
aws_iam_role_arn = "arn:aws:iam::accountID:role/roleName"
    
bucket = "s3://path/for/temp/data"
tableName = "tableName" # Redshift table name

s = f"""CREATE TABLE IF NOT EXISTS {tableName} (country string, data string) 
    USING io.github.spark_redshift_community.spark.redshift 
    OPTIONS (dbtable '{tableName}', tempdir '{bucket}', url '{url}', aws_iam_role '{aws_iam_role_arn}' ); """

spark.sql(s)
         
columns = ["country" ,"data"]
data = [("test-country","test-data")]
df = spark.sparkContext.parallelize(data).toDF(columns)

# Insert data into table
df.write.insertInto(tableName, overwrite=False)
df = spark.sql(f"SELECT * FROM {tableName}")
df.show()
```

------

# Considerazioni e limitazioni relative all'utilizzo del connettore Spark
<a name="emr-spark-redshift-considerations"></a>
+ Si consiglia di attivare SSL per la connessione JDBC da Spark su Amazon EMR ad Amazon Redshift.
+ Come best practice, è consigliabile gestire le credenziali per il cluster Amazon Redshift in Gestione dei segreti AWS . [Gestione dei segreti AWS Per un esempio, consulta Utilizzo per recuperare le credenziali per la connessione ad Amazon](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration.html) Redshift.
+ Si consiglia di passare un ruolo IAM con il parametro `aws_iam_role` per il parametro di autenticazione di Amazon Redshift.
+ L'URI `tempdir` indica una posizione Amazon S3. Questa directory temporanea non viene pulita in automatico e quindi potrebbe generare costi aggiuntivi. 
+ Prendi in considerazione i seguenti consigli per Amazon Redshift:
  + Si consiglia di bloccare l'accesso pubblico al cluster Amazon Redshift.
  + Si consiglia di attivare la [registrazione di log di verifica di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/db-auditing.html).
  + Si consiglia di attivare la [crittografia dei dati inattivi di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/security-server-side-encryption.html).
+ Prendi in considerazione i seguenti consigli per Amazon S3:
  + Si consiglia di [bloccare l'accesso pubblico ai bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-control-block-public-access.html).
  + Si consiglia di utilizzare la [crittografia lato server di Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) per crittografare i bucket Amazon S3 utilizzati.
  + Si consiglia di utilizzare le [policy del ciclo di vita di Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) per definire le regole di conservazione del bucket Amazon S3.
  + Amazon EMR verifica sempre il codice importato dall'open source nell'immagine. Per motivi di sicurezza, non supportiamo i seguenti metodi di autenticazione da Spark ad Amazon S3:
    + Impostazione delle chiavi di AWS accesso nella classificazione della configurazione `hadoop-env`
    + Codifica delle chiavi di AWS accesso nell'URI `tempdir`

Per ulteriori informazioni sull'utilizzo del connettore e dei parametri supportati, consulta le seguenti risorse:
+ [Amazon Redshift integration for Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) (Integrazione di Amazon Redshift per Apache Spark) nella *Guida alla gestione di Amazon Redshift*
+ Il [repository della community `spark-redshift`](https://github.com/spark-redshift-community/spark-redshift#readme) su Github

# Cronologia dei rilasci di Spark
<a name="Spark-release-history"></a>

Nella seguente tabella sono elencati la versione di Spark inclusa in ogni rilascio di Amazon EMR e i componenti installati con l'applicazione. Per le versioni dei componenti in ogni rilascio, consulta la sezione Versione componente per il rilascio in [Versioni del rilascio di Amazon EMR 7.x](emr-release-7x.md), [Versioni di rilascio di Amazon EMR 6.x](emr-release-6x.md) o [Versioni del rilascio di Amazon EMR 5.x](emr-release-5x.md).

**Importante**  
Apache Spark versione 2.3.1, disponibile a partire da Amazon EMR rilascio 5.16.0, risolve [CVE-2018-8024](https://nvd.nist.gov/vuln/detail/CVE-2018-8024) e [CVE-2018-1334](https://nvd.nist.gov/vuln/detail/CVE-2018-1334). Si consiglia di eseguire la migrazione delle versioni precedenti di Spark a Spark 2.3.1 o versioni successive.


**Informazioni sulla versione di Spark**  

| Etichetta di rilascio di Amazon EMR | Versione di Spark | Componenti installati con Spark | 
| --- | --- | --- | 
| emr-7.12.0 | 3.5.6-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.11.0 | 3.5.6-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.10.0 | 3.5.5-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.9.0 | 3.5.5-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.8.0 | 3.5.4-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.7.0 | 3.5.3-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.6.0 | 3.5.3-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.5.0 | 3.5.2-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.4.0 | 3.5.2-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.3.0 | 3.5.1-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.2.0 | 3.5.1-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.36.2 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.1.0 | 3.5.0-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-7.0.0 | 3.5.0-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.15.0 | 3.4.1-amzn-2 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.14.0 | 3.4.1-amzn-1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.13.0 | 3.4.1-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.12.0 | 3.4.0-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.11.1 | 3.3.2-amzn-0.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.11.0 | 3.3.2-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.10.1 | 3.3.1-amzn-0.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.10.0 | 3.3.1-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.9.1 | 3.3.0-amzn-1.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.9.0 | 3.3.0-amzn-1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.8.1 | 3.3.0-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.8.0 | 3.3.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.7.0 | 3.2.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.36.1 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.36.0 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.6.0 | 3.2.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.35.0 | 2.4.8-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.5.0 | 3.1.2-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.4.0 | 3.1.2-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.3.1 | 3.1.1-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.3.0 | 3.1.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.2.1 | 3.0.1-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.2.0 | 3.0.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.1.1 | 3.0.0-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.1.0 | 3.0.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.0.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-6.0.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.34.0 | 2.4.8-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.33.1 | 2.4.7-amzn-1.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.33.0 | 2.4.7-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.32.1 | 2.4.7-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.32.0 | 2.4.7-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.31.1 | 2.4.6-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.31.0 | 2.4.6-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.30.2 | 2.4.5-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.30.1 | 2.4.5-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.30.0 | 2.4.5-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-notebook-env, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.29.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.28.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.28.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.27.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.27.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.26.0 | 2.4.3 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.25.0 | 2.4.3 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.24.1 | 2.4.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.24.0 | 2.4.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.23.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.23.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.22.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.21.2 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.21.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.21.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.20.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.20.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.19.1 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.19.0 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.18.1 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.18.0 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.17.2 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.17.1 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.17.0 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.16.1 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.16.0 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.15.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.15.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.14.2 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.14.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.14.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.13.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.13.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.12.3 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.12.2 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.12.1 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.12.0 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.11.4 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.11.3 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.11.2 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.11.1 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.11.0 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.10.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.10.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.9.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.9.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.8.3 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.8.2 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.8.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.8.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.7.1 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.7.0 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.6.1 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.6.0 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.5.4 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.5.3 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.5.2 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.5.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.5.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.4.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.4.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.3.2 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.3.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.3.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.2.3 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.2.2 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.2.1 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.2.0 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.1.1 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.1.0 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.0.3 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.0.2 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.0.1 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-5.0.0 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.9.6 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.9.5 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.9.4 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.9.3 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.9.2 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.9.1 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.8.5 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.8.4 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.8.3 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.8.2 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.8.1 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.8.0 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.7.4 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.7.3 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.7.2 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.7.1 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.7.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.6.1 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.6.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.5.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.4.0 | 1.6.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.3.0 | 1.6.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.2.0 | 1.5.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.1.0 | 1.5.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 
| emr-4.0.0 | 1.4.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | 

# Utilizzo di viste materializzate con Amazon EMR
<a name="emr-spark-materialized-views"></a>

La versione 7.12.0 e successive di Amazon EMR supporta la creazione e la gestione delle viste materializzate di Apache Iceberg nel Glue Data Catalog. AWS Una vista materializzata è una tabella gestita che memorizza il risultato precalcolato di una query SQL in formato Apache Iceberg e si aggiorna in modo incrementale man mano che le tabelle di origine sottostanti cambiano. È possibile utilizzare le viste materializzate per semplificare le pipeline di trasformazione dei dati e accelerare le prestazioni delle query per carichi di lavoro analitici complessi.

Quando crei una vista materializzata utilizzando Spark su Amazon EMR, la definizione della vista e i metadati vengono archiviati nel Glue Data Catalog. AWS I risultati precalcolati vengono archiviati come tabelle Apache Iceberg in bucket Amazon S3 Tables o bucket Amazon S3 per uso generico all'interno del tuo account. AWS Il AWS Glue Data Catalog monitora automaticamente le tabelle dei sorgenti e aggiorna le viste materializzate utilizzando un'infrastruttura di elaborazione gestita.

**Topics**
+ [Come funzionano le viste materializzate con Amazon EMR](#emr-spark-materialized-views-how-it-works)
+ [Prerequisiti](#emr-spark-materialized-views-prerequisites)
+ [Configurazione di Spark per l'utilizzo di viste materializzate](#emr-spark-materialized-views-configure)
+ [Creazione di viste materializzate](#emr-spark-materialized-views-create)
+ [Invio di query alle viste materializzate](#emr-spark-materialized-views-query)
+ [Aggiornamento delle viste materializzate](#emr-spark-materialized-views-refresh)
+ [Gestione delle viste materializzate](#emr-spark-materialized-views-manage)
+ [Autorizzazioni per le viste materializzate](#emr-spark-materialized-views-permissions)
+ [Monitoraggio delle operazioni di visualizzazione materializzata](#emr-spark-materialized-views-monitoring)
+ [Esempio: flusso di lavoro completo](#emr-spark-materialized-views-example)
+ [Considerazioni e limitazioni](#emr-spark-materialized-views-limitations)

## Come funzionano le viste materializzate con Amazon EMR
<a name="emr-spark-materialized-views-how-it-works"></a>

Le viste materializzate si integrano con Amazon EMR tramite il supporto Iceberg di Apache Spark. Quando configuri la sessione Spark per utilizzare il AWS Glue Data Catalog, puoi creare viste materializzate utilizzando la sintassi SQL standard. L'ottimizzatore Spark può riscrivere automaticamente le query per utilizzare le viste materializzate quando offrono prestazioni migliori, eliminando la necessità di modificare manualmente il codice dell'applicazione.

Il AWS Glue Data Catalog gestisce tutti gli aspetti operativi della manutenzione delle viste materializzate, tra cui:
+ Rilevamento delle modifiche nelle tabelle dei sorgenti utilizzando il livello di metadati di Apache Iceberg
+ Pianificazione ed esecuzione di operazioni di aggiornamento utilizzando il calcolo Spark gestito
+ Determinare se eseguire l'aggiornamento completo o incrementale in base alle modifiche dei dati
+ Memorizzazione dei risultati precalcolati in formato Apache Iceberg per l'accesso a più motori

Puoi interrogare le viste materializzate da Amazon EMR utilizzando le stesse interfacce SQL Spark utilizzate per le tabelle normali. I dati precalcolati sono accessibili anche da altri servizi, tra cui Amazon Athena e Amazon Redshift.

## Prerequisiti
<a name="emr-spark-materialized-views-prerequisites"></a>

Per utilizzare le viste materializzate con Amazon EMR, hai bisogno di:
+ Un account AWS 
+ Un cluster Amazon EMR con la release 7.12.0 o successiva
+ Tabelle di origine in formato Apache Iceberg registrate nel AWS Glue Data Catalog
+ AWS Autorizzazioni Lake Formation configurate per le tabelle di origine e i database di destinazione
+ Un bucket S3 Tables o un bucket S3 per uso generico registrato con AWS Lake Formation per l'archiviazione di dati di viste materializzate

## Configurazione di Spark per l'utilizzo di viste materializzate
<a name="emr-spark-materialized-views-configure"></a>

Per creare e gestire le viste materializzate, configura la sessione Spark con le estensioni Iceberg e le impostazioni del catalogo richieste. La configurazione varia a seconda che le tabelle di origine e le viste materializzate utilizzino i bucket S3 Tables o i bucket S3 per uso generico.

### Configurazione per le tabelle S3
<a name="emr-spark-materialized-views-configure-s3-tables"></a>

Quando utilizzi i bucket S3 Tables per le viste materializzate, configura riferimenti di catalogo separati per le tabelle di origine e le viste materializzate:

```
spark-sql \
  --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \
  --conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog \
  --conf spark.sql.catalog.glue_catalog.type=glue \
  --conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \
  --conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \
  --conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \
  --conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 \
  --conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true \
  --conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog \
  --conf spark.sql.catalog.s3t_catalog.type=glue \
  --conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket \
  --conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 \
  --conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true \
  --conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse \
  --conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 \
  --conf spark.sql.defaultCatalog=s3t_catalog \
  // turn on automatic query rewrite (optional)
  --conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true
```

### Configurazione per bucket S3 per uso generico
<a name="emr-spark-materialized-views-configure-s3-general"></a>

Quando usi i bucket S3 per uso generico, configura un singolo riferimento al catalogo:

```
spark-sql \
  --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \
  --conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog \
  --conf spark.sql.catalog.glue_catalog.type=glue \
  --conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \
  --conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \
  --conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \
  --conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 \
  --conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true \
  --conf spark.sql.defaultCatalog=glue_catalog \
  // turn on automatic query rewrite (optional)
  --conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true
```

### Abilitazione dell'aggiornamento incrementale
<a name="emr-spark-materialized-views-configure-incremental"></a>

Per abilitare l'ottimizzazione dell'aggiornamento incrementale, aggiungi le seguenti proprietà di configurazione alla tua sessione Spark:

```
spark-sql \
  --conf spark.sql.optimizer.incrementalMVRefresh.enabled=true \
```

### Parametri di configurazione
<a name="emr-spark-materialized-views-configure-parameters"></a>

I seguenti parametri di configurazione controllano il comportamento delle viste materializzate:
+ `spark.sql.extensions`— Abilita le estensioni di sessione Iceberg Spark necessarie per il supporto delle viste materializzate.
+ `spark.sql.optimizer.answerQueriesWithMVs.enabled`— Consente la riscrittura automatica delle query per utilizzare le viste materializzate. Imposta su true per attivare questa ottimizzazione.
+ `spark.sql.optimizer.incrementalMVRefresh.enabled`— Abilita l'ottimizzazione dell'aggiornamento incrementale. Impostato su true per elaborare solo i dati modificati durante le operazioni di aggiornamento.

## Creazione di viste materializzate
<a name="emr-spark-materialized-views-create"></a>

Le viste materializzate vengono create utilizzando l'istruzione SQL CREATE MATERIALIZED VIEW. La definizione della vista specifica la logica di trasformazione come una query SQL che fa riferimento a una o più tabelle di origine.

### DLLs
<a name="emr-spark-materialized-views-create-dlls"></a>

**Crea vista**

```
{ CREATE OR REPLACE MATERIALIZED VIEW | CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] }
   view_identifier
  [ view_clauses ]
  [ schedule_clauses ]
  AS [ select_statement ]

view_clauses =
  { [ LOCATION location ] |
    [ PARTITIONED BY (col [, ...]) ] |
    [ COMMENT view_comment ] |
    [ SCHEDULE [ REFRESH ] schedule_clause ] }

schedule_clause =
  { EVERY number { HOUR | HOURS | DAY | DAYS | WEEK | WEEKS } }
```

**Nota**  
Le view\$1clauses devono apparire prima di select\$1statement.

### Creazione di una vista materializzata di base
<a name="emr-spark-materialized-views-create-basic"></a>

L'esempio seguente crea una vista materializzata che aggrega i dati degli ordini per cliente, utilizza nomi di tabelle completi con una convenzione di denominazione in tre parti nella definizione della vista:

```
CREATE MATERIALIZED VIEW customer_orders
AS 
SELECT 
    customer_name, 
    COUNT(*) as order_count, 
    SUM(amount) as total_amount 
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```

### Creazione di una vista materializzata con aggiornamento automatico
<a name="emr-spark-materialized-views-create-auto-refresh"></a>

Per configurare l'aggiornamento automatico, specificate una pianificazione di aggiornamento durante la creazione della vista utilizzando nomi di tabella completi con una convenzione di denominazione in tre parti nella definizione della vista:

```
CREATE MATERIALIZED VIEW customer_orders
SCHEDULE REFRESH EVERY 1 HOUR
AS 
SELECT 
    customer_name, 
    COUNT(*) as order_count, 
    SUM(amount) as total_amount 
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```

### Creazione di una vista materializzata con riferimenti tra cataloghi
<a name="emr-spark-materialized-views-create-cross-catalog"></a>

Quando le tabelle di origine si trovano in un catalogo diverso rispetto alla vista materializzata, utilizzate nomi di tabella completi con una convenzione di denominazione in tre parti sia nel nome della vista che nella definizione della vista:

```
CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary
AS 
SELECT 
    customer_name, 
    COUNT(*) as order_count, 
    SUM(amount) as total_amount 
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```

## Invio di query alle viste materializzate
<a name="emr-spark-materialized-views-query"></a>

Dopo aver creato una vista materializzata, puoi interrogarla come qualsiasi altra tabella utilizzando le istruzioni SQL SELECT standard:

```
SELECT * FROM customer_orders;
```

### Riscrittura automatica delle query
<a name="emr-spark-materialized-views-query-rewrite"></a>

Quando la riscrittura automatica delle query è abilitata, l'ottimizzatore Spark analizza le query e utilizza automaticamente le viste materializzate quando possono migliorare le prestazioni. Ad esempio, se esegui la seguente query:

```
SELECT 
    customer_name, 
    COUNT(*) as order_count, 
    SUM(amount) as total_amount 
FROM orders
GROUP BY customer_name;
```

L'ottimizzatore Spark riscrive automaticamente questa query per utilizzare la vista materializzata customer\$1orders invece di elaborare la tabella degli ordini di base, a condizione che la vista materializzata sia aggiornata.

### Verifica della riscrittura automatica delle query
<a name="emr-spark-materialized-views-query-verify"></a>

Per verificare se una query utilizza la riscrittura automatica delle query, utilizzate il comando EXPLAIN EXTENDED:

```
EXPLAIN EXTENDED
SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount 
FROM orders
GROUP BY customer_name;
```

Nel piano di esecuzione, cercate il nome della vista materializzata nell' BatchScanoperazione. Se il piano mostra BatchScan glue\$1catalog.analytics.customer\$1orders anziché glue\$1catalog.sales.orders, la query è stata riscritta automaticamente per utilizzare la BatchScan vista materializzata.

**Nota**  
La riscrittura automatica delle query richiede del tempo prima che la cache dei metadati Spark venga compilata dopo la creazione di una vista materializzata. Questo processo viene in genere completato entro 30 secondi.

## Aggiornamento delle viste materializzate
<a name="emr-spark-materialized-views-refresh"></a>

È possibile aggiornare le viste materializzate utilizzando due metodi: aggiornamento completo o aggiornamento incrementale. L'aggiornamento completo ricalcola l'intera vista materializzata da tutti i dati della tabella di base, mentre l'aggiornamento incrementale elabora solo i dati che sono stati modificati dall'ultimo aggiornamento.

### Aggiornamento manuale completo
<a name="emr-spark-materialized-views-refresh-full"></a>

Per eseguire un aggiornamento completo di una vista materializzata:

```
REFRESH MATERIALIZED VIEW customer_orders FULL;
```

Dopo aver eseguito questo comando, interroga la vista materializzata per verificare i risultati aggiornati:

```
SELECT * FROM customer_orders;
```

### Aggiornamento incrementale manuale
<a name="emr-spark-materialized-views-refresh-incremental"></a>

Per eseguire un aggiornamento incrementale, assicurati che l'aggiornamento incrementale sia abilitato nella configurazione della sessione Spark, quindi esegui:

```
REFRESH MATERIALIZED VIEW customer_orders;
```

Il AWS Glue Data Catalog determina automaticamente se l'aggiornamento incrementale è applicabile in base alla definizione della vista e alla quantità di dati modificati. Se l'aggiornamento incrementale non è possibile, l'operazione torna all'aggiornamento completo.

### Verifica dell'esecuzione dell'aggiornamento incrementale
<a name="emr-spark-materialized-views-refresh-verify"></a>

Per confermare che l'aggiornamento incrementale sia stato eseguito correttamente, puoi controllare le proprietà della `lastRefreshType` tabella eseguendo i seguenti comandi:

```
SHOW TBLPROPERTIES <mvName>("lastRefreshType")
```

Inoltre, questo può essere ottenuto anche abilitando la registrazione di debug modificando la configurazione del registro Spark:

1. Apri il file di configurazione di Spark log4j:

   ```
   sudo vim /usr/lib/spark/conf/log4j2.properties
   ```

1. Aggiungi le seguenti configurazioni del logger:

   ```
   logger.spark.name = org.apache.spark.sql
   logger.spark.level = debug
   
   logger.inmemcache.name = org.apache.spark.sql.InMemMvMetadataCache
   logger.inmemcache.level = off
   ```

1. Dopo aver eseguito un'operazione di aggiornamento, cerca il seguente messaggio nell'output di Spark:

   ```
   DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh
   ```

## Gestione delle viste materializzate
<a name="emr-spark-materialized-views-manage"></a>

Amazon EMR fornisce comandi SQL per la gestione del ciclo di vita delle viste materializzate.

### Descrivere una vista materializzata
<a name="emr-spark-materialized-views-manage-describe"></a>

Per visualizzare i metadati relativi a una vista materializzata, tra cui la definizione, lo stato di aggiornamento e il timestamp dell'ultimo aggiornamento:

```
DESCRIBE EXTENDED customer_orders;
```

### Alterazione di una vista materializzata
<a name="emr-spark-materialized-views-manage-alter"></a>

Per modificare la pianificazione di aggiornamento di una vista materializzata esistente:

```
ALTER MATERIALIZED VIEW customer_orders 
ADD SCHEDULE REFRESH EVERY 2 HOURS;
```

Per rimuovere l'aggiornamento automatico:

```
ALTER MATERIALIZED VIEW customer_orders 
DROP SCHEDULE;
```

### Eliminazione di una vista materializzata
<a name="emr-spark-materialized-views-manage-drop"></a>

Per eliminare una vista materializzata:

```
DROP MATERIALIZED VIEW customer_orders;
```

Questo comando rimuove la definizione della vista materializzata dal AWS Glue Data Catalog ed elimina i dati della tabella Iceberg sottostante dal bucket S3.

## Autorizzazioni per le viste materializzate
<a name="emr-spark-materialized-views-permissions"></a>

Per creare e gestire viste materializzate, devi configurare le autorizzazioni di AWS Lake Formation. Il ruolo IAM che crea la vista materializzata (il ruolo definer) richiede autorizzazioni specifiche sulle tabelle di origine e sui database di destinazione.

### Autorizzazioni richieste per il ruolo di definitore
<a name="emr-spark-materialized-views-permissions-definer"></a>

Il ruolo che definisce deve avere i seguenti permessi di Lake Formation:
+ Nelle tabelle di origine: autorizzazioni SELECT o ALL senza filtri di riga, colonna o cella
+ Sul database di destinazione: autorizzazione CREATE\$1TABLE
+ Sul AWS Glue Data Catalog GetTable e sulle autorizzazioni CreateTable API

Quando si crea una vista materializzata, l'ARN del ruolo definitore viene memorizzato nella definizione della vista. Il AWS Glue Data Catalog assume questo ruolo durante l'esecuzione di operazioni di aggiornamento automatico. Se il ruolo di definitore perde l'accesso alle tabelle di origine, le operazioni di aggiornamento falliranno fino al ripristino delle autorizzazioni.

### Concessione dell'accesso alle viste materializzate
<a name="emr-spark-materialized-views-permissions-access"></a>

Per concedere ad altri utenti l'accesso per interrogare una vista materializzata, usa AWS Lake Formation per concedere l'autorizzazione SELECT sulla tabella delle viste materializzate. Gli utenti possono interrogare la vista materializzata senza richiedere l'accesso diretto alle tabelle di origine sottostanti.

Per informazioni dettagliate sulla configurazione delle autorizzazioni di Lake Formation, consulta Concessione e revoca delle autorizzazioni sulle risorse del Data Catalog nella Lake Formation Developer Guide. AWS 

## Monitoraggio delle operazioni di visualizzazione materializzata
<a name="emr-spark-materialized-views-monitoring"></a>

Il AWS Glue Data Catalog pubblica metriche e log per le operazioni di aggiornamento delle viste materializzate su Amazon. CloudWatch Puoi monitorare lo stato dell'aggiornamento, la durata e il volume di dati elaborati tramite metriche. CloudWatch 

### Visualizzazione delle metriche di aggiornamento
<a name="emr-spark-materialized-views-monitoring-metrics"></a>

Per visualizzare le metriche di aggiornamento delle viste materializzate:

1. Apri la console. CloudWatch 

1. Scegli Metriche dal pannello di navigazione.

1. Selezionare lo spazio dei nomi Glue.

1. Filtra le metriche in base al nome della vista materializzata.

### Configurazione degli allarmi
<a name="emr-spark-materialized-views-monitoring-alarms"></a>

Per ricevere notifiche quando le operazioni di aggiornamento falliscono o superano la durata prevista, crea CloudWatch allarmi sulle metriche delle viste materializzate. Puoi anche configurare EventBridge le regole di Amazon per attivare risposte automatiche agli eventi di aggiornamento.

## Esempio: flusso di lavoro completo
<a name="emr-spark-materialized-views-example"></a>

L'esempio seguente dimostra un flusso di lavoro completo per la creazione e l'utilizzo di una vista materializzata su Amazon EMR.

1. Connect al nodo primario del cluster EMR tramite SSH.

1. Crea una tabella di base con dati di esempio:

   ```
   spark-sql \
     --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \
     --conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog \
     --conf spark.sql.catalog.glue_catalog.type=glue \
     --conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \
     --conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \
     --conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \
     --conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 \
     --conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true \
     --conf spark.sql.defaultCatalog=glue_catalog \
     --conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true 
   
   
   CREATE DATABASE IF NOT EXISTS sales;
   
   USE sales;
   
   CREATE TABLE orders (
       id INT,
       customer_name STRING,
       amount DECIMAL(10,2),
       order_date DATE
   );
   
   INSERT INTO orders VALUES 
       (1, 'John Doe', 150.00, DATE('2024-01-15')),
       (2, 'Jane Smith', 200.50, DATE('2024-01-16')),
       (3, 'Bob Johnson', 75.25, DATE('2024-01-17'));
   ```

1. Crea una vista materializzata:

   ```
   CREATE MATERIALIZED VIEW customer_summary
   AS 
   SELECT 
       customer_name, 
       COUNT(*) as order_count, 
       SUM(amount) as total_amount 
   FROM glue_catalog.sales.orders
   GROUP BY customer_name;
   ```

1. Interroga la vista materializzata:

   ```
   SELECT * FROM customer_summary;
   ```

1. Inserisci dati aggiuntivi nella tabella di base:

   ```
   INSERT INTO orders VALUES 
       (4, 'Jane Smith', 350.00, DATE('2024-01-18')),
       (5, 'Bob Johnson', 100.25, DATE('2024-01-19'));
   ```

1. Aggiorna la vista materializzata.

   ```
   REFRESH MATERIALIZED VIEW customer_summary FULL;
   ```

1. Verifica i risultati aggiornati:

   ```
   SELECT * FROM customer_summary;
   ```

## Considerazioni e limitazioni
<a name="emr-spark-materialized-views-limitations"></a>

Considera quanto segue quando utilizzi viste materializzate con Amazon EMR:
+ Le viste materializzate richiedono Amazon EMR versione 7.12.0 o successiva.
+ Le tabelle di origine devono essere tabelle Apache Iceberg registrate nel AWS Glue Data Catalog. Le tabelle Apache Hive, Apache Hudi e Linux Foundation Delta Lake non sono supportate al momento del lancio.
+ Le tabelle di origine devono risiedere nella stessa AWS regione e nello stesso AWS account della vista materializzata.
+ Tutte le tabelle dei sorgenti devono essere governate da AWS Lake Formation. Le autorizzazioni solo IAM e l'accesso ibrido non sono supportati.
+ Le viste materializzate non possono fare riferimento alle viste del AWS Glue Data Catalog, alle viste multidialettali o ad altre viste materializzate come tabelle di origine.
+ Il ruolo View Definer deve disporre dell'accesso completo in lettura (autorizzazione SELECT o ALL) su tutte le tabelle di origine senza applicare filtri di riga, colonna o cella.
+ Le viste materializzate alla fine sono coerenti con le tabelle di origine. Durante la finestra di aggiornamento, le query possono restituire dati non aggiornati. Esegui l'aggiornamento manuale per una coerenza immediata.
+ L'intervallo minimo di aggiornamento automatico è di un'ora.
+ L'aggiornamento incrementale supporta un sottoinsieme limitato di operazioni SQL. La definizione della vista deve essere un singolo blocco SELECT-FROM-WHERE-GROUP BY-HAVING e non può contenere operazioni di set, sottoquery, la parola chiave DISTINCT in SELECT o funzioni aggregate, funzioni di finestra o join diversi da INNER JOIN.
+ L'aggiornamento incrementale non supporta funzioni definite dall'utente o determinate funzioni integrate. È supportato solo un sottoinsieme delle funzioni integrate di Spark SQL.
+ La riscrittura automatica delle query considera solo le viste materializzate le cui definizioni appartengono a un sottoinsieme SQL limitato, simile alle restrizioni di aggiornamento incrementale.
+ Le operazioni di aggiornamento completo sovrascrivono l'intera tabella e rendono non disponibili le istantanee precedenti.
+ Gli identificatori contenenti caratteri speciali diversi dai caratteri alfanumerici e dai caratteri di sottolineatura non sono supportati nelle query CREATE MATERIALIZED VIEW.
+ Le colonne delle viste materializzate che iniziano con il prefisso \$1\$1ivm sono riservate all'uso del sistema. AWS si riserva il diritto di modificare o rimuovere queste colonne nelle versioni future.
+ Le clausole SORT BY, LIMIT, OFFSET, CLUSTER BY e ORDER BY non sono supportate nelle definizioni delle viste materializzate.
+ Le tabelle di origine tra regioni e tra account non sono supportate.
+ Le funzioni non deterministiche come rand () o current\$1timestamp () non sono supportate nelle definizioni delle viste materializzate.