

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

# Tutorial: Nozioni di base su Amazon EMR
<a name="emr-gs"></a>

Segui un flusso di lavoro per configurare rapidamente un cluster Amazon EMR ed eseguire un'applicazione Spark.

## Configurazione del cluster Amazon EMR
<a name="emr-getting-started-overview"></a>

Con Amazon EMR è possibile configurare un cluster per elaborare e analizzare i dati con framework di big data in pochi minuti. Questo tutorial mostra come avviare un cluster di esempio utilizzando Spark e come eseguire un semplice PySpark script archiviato in un bucket Amazon S3. Copre le attività essenziali di Amazon EMR in tre categorie principali del flusso di lavoro: pianificazione e configurazione, gestione e pulizia.

Nel corso del tutorial sono disponibili collegamenti ad argomenti più dettagliati e idee per ulteriori fasi nella sezione [Fasi successive](#emr-gs-next-steps). In caso di domande o problemi, contatta il team Amazon EMR sul nostro [Forum di discussione](https://forums.aws.amazon.com/forum.jspa?forumID=52).

![\[Diagramma del flusso di lavoro per Amazon EMR che delinea le tre principali categorie di flussi di lavoro: pianificazione e configurazione, gestione e pulizia.\]](http://docs.aws.amazon.com/it_it/emr/latest/ManagementGuide/images/emr-workflow.png)


**Prerequisiti**
+ Prima di avviare un cluster Amazon EMR, assicurati di completare le attività descritte in [Prima di configurare Amazon EMR](emr-setting-up.md).

**Costo**
+ Il cluster di esempio che crei viene eseguito in un ambiente reale. Il cluster accumula costi minimi. Per evitare costi aggiuntivi, assicurati di completare le processi di pulizia nell'ultima fase di questo tutorial. I costi maturano alla tariffa al secondo in base ai prezzi di Amazon EMR. I costi variano anche in base alla Regione. Per ulteriori informazioni, consulta [Prezzi di Amazon EMR](https://aws.amazon.com/emr/pricing).
+ Potrebbero esserci degli costi minimi per i file di piccole dimensioni che archivi su Amazon S3. Alcuni o tutti i costi per Amazon S3 potrebbero non essere addebitati se rientri nei limiti di utilizzo del AWS piano gratuito. Per ulteriori informazioni, consulta [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing) e [Piano gratuito di AWS](https://aws.amazon.com/free/).

## Fase 1: configurare le risorse di dati e avviare un cluster Amazon EMR
<a name="emr-getting-started-plan-and-configure"></a>

### Preparare la archiviazione per Amazon EMR
<a name="emr-getting-started-prepare-storage"></a>

Quando utilizzi Amazon EMR, puoi scegliere tra una varietà di file system per archiviare dati di input, dati di output e file di log. In questo tutorial, utilizzi EMRFS per archiviare i dati in un bucket S3. EMRFS è un'implementazione del file system Hadoop che permette di leggere e scrivere file standard su Amazon S3. Per ulteriori informazioni, consulta [Utilizzo di sistemi di storage e file con Amazon EMR](emr-plan-file-systems.md).

Per creare un bucket per questo tutorial, segui le istruzioni in [Come creare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) nella *Guida per l'utente della console Amazon Simple Storage Service*. Crea il bucket nella stessa AWS regione in cui prevedi di lanciare il tuo cluster Amazon EMR. Ad esempio, US West (Oregon) us-west-2 (Stati Uniti occidentali (Oregon) us-west-2). 

I bucket e le cartelle utilizzati con Amazon EMR presentano le seguenti limitazioni:
+ I nomi devono includere lettere minuscole, numeri, punti (.) e trattini (-).
+ I nomi non devono terminare con numeri.
+ Il nome del bucket deve essere univoco *per tutti gli account AWS *.
+ Una cartella di output deve essere vuota.

### Preparazione di un'applicazione con i dati di input per Amazon EMR
<a name="emr-getting-started-prepare-app"></a>

Il modo più comune per preparare un'applicazione per Amazon EMR è caricare l'applicazione e i relativi dati di input su Amazon S3. Poi, quando invii il lavoro al cluster, specificare le posizioni Amazon S3 per i vostri script e dati.

In questo passaggio, carichi uno PySpark script di esempio nel tuo bucket Amazon S3. Ti abbiamo fornito uno PySpark script da utilizzare. Lo script elabora i dati di ispezione degli stabilimenti alimentari e restituisce un file dei risultati nel bucket S3. Il file di risultati elenca i primi dieci stabilimenti alimentari con il maggior numero di violazioni di tipo "Red (Rosso)".

Inoltre, carichi dati di input di esempio su Amazon S3 per l'elaborazione dello PySpark script. I dati di input sono una versione modificata dei risultati delle ispezioni condotte dal 2006 al 2020 dal Dipartimento di sanità pubblica della Contea di King, Washington. Per ulteriori informazioni, consulta [Dati pubblici della Contea di King: dati di ispezione sugli stabilimenti alimentari](https://data.kingcounty.gov/Health-Wellness/Food-Establishment-Inspection-Data/f29f-zza5). Non scaricate i dati dei ristoranti di questo tutorial direttamente dal sito web di King County, perché si tratta di un file molto grande. Di seguito forniamo un download con un file con meno record, per facilitare il completamento del tutorial. Di seguito sono riportare righe di esempio del set di dati:

```
name,inspection_result,inspection_closed_business,violation_type,violation_points
100 LB CLAM,Unsatisfactory,FALSE,BLUE,5
100 PERCENT NUTRICION,Unsatisfactory,FALSE,BLUE,5
7-ELEVEN #2361-39423A,Complete,FALSE,,0
```

**Per preparare lo PySpark script di esempio per EMR**

1. Copia il codice di esempio fornito di seguito in un nuovo file nell'editor che hai scelto.

   ```
   import argparse
   
   from pyspark.sql import SparkSession
   
   def calculate_red_violations(data_source, output_uri):
       """
       Processes sample food establishment inspection data and queries the data to find the top 10 establishments
       with the most Red violations from 2006 to 2020.
   
       :param data_source: The URI of your food establishment data CSV, such as 's3://amzn-s3-demo-bucket/food-establishment-data.csv'.
       :param output_uri: The URI where output is written, such as 's3://amzn-s3-demo-bucket/restaurant_violation_results'.
       """
       with SparkSession.builder.appName("Calculate Red Health Violations").getOrCreate() as spark:
           # Load the restaurant violation CSV data
           if data_source is not None:
               restaurants_df = spark.read.option("header", "true").csv(data_source)
   
           # Create an in-memory DataFrame to query
           restaurants_df.createOrReplaceTempView("restaurant_violations")
   
           # Create a DataFrame of the top 10 restaurants with the most Red violations
           top_red_violation_restaurants = spark.sql("""SELECT name, count(*) AS total_red_violations 
             FROM restaurant_violations 
             WHERE violation_type = 'RED' 
             GROUP BY name 
             ORDER BY total_red_violations DESC LIMIT 10""")
   
           # Write the results to the specified output URI
           top_red_violation_restaurants.write.option("header", "true").mode("overwrite").csv(output_uri)
   
   if __name__ == "__main__":
       parser = argparse.ArgumentParser()
       parser.add_argument(
           '--data_source', help="The URI for you CSV restaurant data, like an S3 bucket location.")
       parser.add_argument(
           '--output_uri', help="The URI where output is saved, like an S3 bucket location.")
       args = parser.parse_args()
   
       calculate_red_violations(args.data_source, args.output_uri)
   ```

1. Salva il file con nome `health_violations.py`.

1. Carica `health_violations.py` su Amazon S3 nel bucket che hai creato per questo tutorial. Per istruzioni, consulta [Caricamento di un oggetto in un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket) nella *Guida alle operazioni di base di Amazon Simple Storage Service*.

**Preparazione dei dati di input di esempio per EMR**

1. Scarica il file zip [food\$1establishment\$1data.zip](samples/food_establishment_data.zip).

1. Decomprimere e salvare `food_establishment_data.zip` come `food_establishment_data.csv` sulla tua macchina.

1. Carica il file CSV nel bucket S3 creato per questo tutorial. Per istruzioni, consulta [Caricamento di un oggetto in un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket) nella *Guida alle operazioni di base di Amazon Simple Storage Service*.

Per ulteriori informazioni sulla configurazione di dati per EMR, consulta [Prepara i dati di input per l'elaborazione con Amazon EMR](emr-plan-input.md).

### Avvio di un cluster Amazon EMR
<a name="emr-getting-started-launch-sample-cluster"></a>

Dopo aver preparato una posizione di archiviazione e l'applicazione, è possibile avviare un cluster Amazon EMR di esempio. In questa fase, avvii un cluster Apache Spark utilizzando l'ultima [versione di rilascio di Amazon EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-release-components.html).

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

**Per avviare un cluster con Spark installato con la 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 **EMR su EC2**, nel riquadro di navigazione a sinistra, scegli **Cluster** e quindi seleziona **Crea cluster**.

1. Nella pagina **Crea Cluster**, prendi nota dei valori predefiniti per **Versione**, **Tipo di istanza**, **Numero di istanze** e **Autorizzazioni**. Questi campi si compilano in automatico con i valori che funzionano per i cluster per uso generico.

1. Nel campo **Nome cluster**, inserisci un nome di cluster univoco per aiutarti a identificare il cluster, ad esempio. *My first cluster* Il nome del cluster non può contenere i caratteri <, >, \$1, \$1 o `(backtick).

1. In **Applicazioni**, seleziona l'opzione **Spark** per installare Spark nel cluster.
**Nota**  
Scegli le applicazioni che desideri nel cluster Amazon EMR prima di avviarlo. Non è possibile aggiungere o rimuovere applicazioni da un cluster dopo l'avvio.

1. In **Registri del cluster**, seleziona la casella di spunta Pubblica log specifici del cluster su Amazon S3. Sostituisci il valore di **Posizione di Amazon S3** con il bucket Amazon S3 che hai creato seguito da **/logs**. Ad esempio, **s3://amzn-s3-demo-bucket/logs**. Aggiungendo **/logs** si crea una nuova cartella chiamata "logs" nel tuo bucket, nella quale Amazon EMR copierà i file di log del cluster.

1. In **Configurazione e autorizzazioni di sicurezza**, scegli la tua **coppia di chiavi EC2**. **Nella stessa sezione, seleziona il menu a discesa **Service role for Amazon EMR** e scegli EMR\$1. DefaultRole** **Quindi, seleziona il menu a discesa del **profilo IAM role for instance** e scegli EMR\$1 \$1. EC2 DefaultRole** 

1. Scegli **Crea cluster** per avviare il cluster e apri la pagina dei dettagli del cluster.

1. Cerca l'indicazione **Stato** accanto al nome del cluster. Lo stato cambia da **Avvio in corso** a **In esecuzione** a **In attesa** mentre Amazon EMR effettua il provisioning del cluster. Potrebbe essere necessario scegliere l'icona di aggiornamento a destra o aggiornare il browser per visualizzare gli aggiornamenti di stato.

Quando lo stato del cluster passa a **In attesa**, il cluster è attivo, in esecuzione e pronto per accettare lavoro. Per ulteriori informazioni sulla lettura del riepilogo di un cluster, consulta [Visualizza lo stato e i dettagli del cluster Amazon EMR](emr-manage-view-clusters.md). Per ulteriori informazioni sullo stato del cluster, consulta [Comprensione del ciclo di vita del cluster](emr-overview.md#emr-overview-cluster-lifecycle).

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

**Per avviare un cluster con Spark installato con AWS CLI**

1. Crea ruoli predefiniti IAM che puoi utilizzare per creare il cluster utilizzando il comando seguente.

   ```
   aws emr create-default-roles
   ```

   Per ulteriori informazioni su come `create-default-roles`, consulta la [Guida di riferimento ai comandi della AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/emr/create-default-roles.html).

1. Crea un cluster Spark con il comando seguente. Inserisci un nome per il cluster attraverso l'opzione `--name` e specifica il nome della coppia di chiavi EC2 con l'opzione `--ec2-attributes`.

   ```
   aws emr create-cluster \
   --name "<My First EMR Cluster>" \
   --release-label <emr-5.36.2> \
   --applications Name=Spark \
   --ec2-attributes KeyName=<myEMRKeyPairName> \
   --instance-type m5.xlarge \
   --instance-count 3 \
   --use-default-roles
   ```

   Prendi nota degli altri valori richiesti per `--instance-type`, `--instance-count` e `--use-default-roles`. Questi valori sono stati scelti per i cluster generici. Per ulteriori informazioni su come `create-cluster`, consulta la [Guida di riferimento ai comandi della AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/emr/create-cluster.html).
**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, rimuovili o sostituiscili con un accento circonflesso (^).

   L'output restituito dovrebbe essere simile al seguente. L'output mostra il `ClusterId` e `ClusterArn` del nuovo cluster. Nota il tuo `ClusterId`. Utilizza il `ClusterId` per verificare lo stato del cluster e inviare il lavoro.

   ```
   {
       "ClusterId": "myClusterId",
       "ClusterArn": "myClusterArn"
   }
   ```

1. Verifica lo stato del cluster con il comando seguente.

   ```
   aws emr describe-cluster --cluster-id <myClusterId>						
   ```

   Verrà visualizzato un output come il seguente con l'oggetto `Status` per il nuovo cluster.

   ```
   {
       "Cluster": {
           "Id": "myClusterId",
           "Name": "My First EMR Cluster",
           "Status": {
               "State": "STARTING",
               "StateChangeReason": {
                   "Message": "Configuring cluster software"
               }
           }
        }
   }
   ```

   La valore `State` cambia da `STARTING` a `RUNNING` a `WAITING` mentre Amazon EMR effettua il provisioning del cluster.

Lo stato del cluster passa a `WAITING` quando il cluster è attivo, in esecuzione e pronto per accettare lavoro. Per ulteriori informazioni sullo stato del cluster, consulta [Comprensione del ciclo di vita del cluster](emr-overview.md#emr-overview-cluster-lifecycle).

------

## Fase 2: invia il lavoro al tuo cluster Amazon EMR
<a name="emr-getting-started-manage"></a>

### Invia il lavoro e visualizza i risultati
<a name="emr-getting-started-submit-spark-step"></a>

Dopo aver avviato un cluster, è possibile inviare il lavoro al cluster in esecuzione per elaborare e analizzare i dati. Invia lavoro a un cluster Amazon EMR come una *fase*. Una fase è un'unità di lavoro costituita da uno o più operazioni. Ad esempio, potresti inviare una fase per calcolare valori o per trasferire ed elaborare dati. Puoi inviare fasi quando crei un cluster o a un cluster in esecuzione. In questa parte del tutorial, invii `health_violations.py` come fase al cluster in esecuzione. Per ulteriori informazioni sulle fasi, consulta [Invia il lavoro a un cluster Amazon EMR](emr-work-with-steps.md).

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

**Per inviare un'applicazione Spark procedendo passo dopo passo con la 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 **EMR su EC2**, nel riquadro di navigazione a sinistra, scegli **Cluster** e quindi seleziona il cluster a cui desideri inviare il lavoro. Lo stato del cluster deve essere **In attesa**.

1. Scegli la scheda **Steps** (Fasi), quindi scegli **Add step** (Aggiungi fase).

1. Configura la fase in base alle seguenti linee guida:
   + Per **Type** (Tipo), scegli **Spark application** (Applicazione Spark). Dovresti visualizzare altri campi per **Deploy mode** (Modalità di implementazione), **Application location** (Percorso dell'applicazione) e **Spark-submit options** (Opzioni Spark-submit).
   + In **Name** (Nome), inserisci un nuovo nome. Se in un cluster sono presenti più fasi, l'assegnazione di un nome a ciascuna fase aiuta a tenerne traccia.
   + Per **Deploy mode** (Modalità di implementazione), lascia il valore predefinito **Cluster mode** (Modalità cluster). Per ulteriori informazioni sulle modalità di implementazione di Spark, consulta la sezione [Cluster mode overview](https://spark.apache.org/docs/latest/cluster-overview.html) (Panoramica della modalità cluster) nella documentazione di Apache Spark.
   + Per **Posizione dell'applicazione**, inserisci la posizione dello `health_violations.py` script in Amazon S3, ad esempio. *s3://amzn-s3-demo-bucket/health\$1violations.py*
   + Lascia vuoto il campo **Spark-submit options** (Opzioni Spark-submit). Per ulteriori informazioni sulle opzioni di `spark-submit`, consulta la sezione [Launching applications with spark-submit](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit) (Avvio di applicazioni con spark-submit). 
   + Nel campo **Argomenti**, inserisci i seguenti argomenti e valori:

     ```
     --data_source s3://amzn-s3-demo-bucket/food_establishment_data.csv
     --output_uri s3://amzn-s3-demo-bucket/myOutputFolder
     ```

     Sostituisci *s3://amzn-s3-demo-bucket/food\$1establishment\$1data.csv* con l'URI del bucket S3 i dati di input in cui hai preparato. [Preparazione di un'applicazione con i dati di input per Amazon EMR](#emr-getting-started-prepare-app)

     Sostituiscilo *amzn-s3-demo-bucket* con il nome del bucket che hai creato per questo tutorial e sostituiscilo *myOutputFolder* con un nome per la cartella di output del cluster.
   + Per **Action on failure** (Operazione in caso di errore), accetta l'opzione predefinita, ossia **Continue** (Continua). In questo modo, se la fase riscontra un errore, il cluster continua a funzionare.

1. Seleziona **Aggiungi** per inviare la fase. La fase viene visualizzata nella console con lo stato **In attesa**.

1. Monitora lo stato della fase. Dovrebbe passare da **Pending** (In attesa) a **Running** (In esecuzione) a **Completed** (Completata). Per aggiornare lo stato nella console, scegli l'icona di aggiornamento a destra di **Filter** (Filtro). Lo script richiede circa un minuto per l'esecuzione. Quando lo stato diventa **Completed** (Completata), significa che la fase è stata completata correttamente.

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

**Per inviare un'applicazione Spark, procedi passo con il AWS CLI**

1. Accertati di disporre del `ClusterId` del cluster che hai avviato in [Avvio di un cluster Amazon EMR](#emr-getting-started-launch-sample-cluster). In alternativa, puoi recuperare l'ID del cluster con il comando seguente.

   ```
   aws emr list-clusters --cluster-states WAITING							
   ```

1.  Invia `health_violations.py` come fase con il comando `add-steps` e il `ClusterId`.
   + Puoi specificare un nome per la tua fase *"My Spark Application"* sostituendo. Nell'`Args`array, *s3://amzn-s3-demo-bucket/health\$1violations.py* sostituiscilo con la posizione dell'`health_violations.py`applicazione.
   + Sostituisci *s3://amzn-s3-demo-bucket/food\$1establishment\$1data.csv* con la posizione S3 del tuo `food_establishment_data.csv` set di dati.
   + Sostituiscilo *s3://amzn-s3-demo-bucket/MyOutputFolder* con il percorso S3 del bucket designato e un nome per la cartella di output del cluster.
   + `ActionOnFailure=CONTINUE` indica che il cluster continua a funzionare qualora la fase avesse esito negativo.

   ```
   aws emr add-steps \
   --cluster-id <myClusterId> \
   --steps Type=Spark,Name="<My Spark Application>",ActionOnFailure=CONTINUE,Args=[<s3://amzn-s3-demo-bucket/health_violations.py>,--data_source,<s3://amzn-s3-demo-bucket/food_establishment_data.csv>,--output_uri,<s3://amzn-s3-demo-bucket/MyOutputFolder>]
   ```

   Per ulteriori informazioni sull'invio di fasi mediante la CLI, consulta la [Guida di riferimento ai comandi della AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/emr/add-steps.html).

   Dopo aver inviato la fase, dovresti visualizzare l'output simile al seguente con un elenco di `StepIds`. Dal momento che hai inviato una sola fase, vedrai un solo ID nell'elenco. Copia il tuo ID della fase. Utilizzare l'ID della fase per verificare lo stato della fase.

   ```
   {
       "StepIds": [
           "s-1XXXXXXXXXXA"
       ]
   }
   ```

1. Esegui una query sullo stato della fase con il comando `describe-step`.

   ```
   aws emr describe-step --cluster-id <myClusterId> --step-id <s-1XXXXXXXXXXA>							
   ```

   L'output restituito dovrebbe essere simile al seguente con le informazioni sul fase.

   ```
   {
       "Step": {
           "Id": "s-1XXXXXXXXXXA",
           "Name": "My Spark Application",
           "Config": {
               "Jar": "command-runner.jar",
               "Properties": {},
               "Args": [
                   "spark-submit",
                   "s3://amzn-s3-demo-bucket/health_violations.py",
                   "--data_source",
                   "s3://amzn-s3-demo-bucket/food_establishment_data.csv",
                   "--output_uri",
                   "s3://amzn-s3-demo-bucket/myOutputFolder"
               ]
           },
           "ActionOnFailure": "CONTINUE",
           "Status": {
               "State": "COMPLETED"
           }
       }
   }
   ```

   Lo `State` della fase cambia da `PENDING` a `RUNNING` a `COMPLETED` durante la sua esecuzione. La fase richiede circa un minuto per essere eseguita, quindi potrebbe essere necessario controllarne lo stato più volte.

Saprai che la fase è terminata correttamente quando il relativo `State` passa a `COMPLETED`.

------

Per ulteriori informazioni sul ciclo di vita delle fasi, consulta [Esecuzione di fasi per elaborare i dati](emr-overview.md#emr-overview-steps).

### Visualizzazione dei risultati
<a name="emr-getting-started-view-results"></a>

Se l'esecuzione della fase è stata riuscita, puoi visualizzarne i risultati nella cartella output di Amazon S3.

**Visualizzazione dei risultati di `health_violations.py`**

1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Scegli il **Bucket name (Nome bucket)** e la cartella di output che hai specificato all'invio della fase. Ad esempio, *amzn-s3-demo-bucket* e poi*myOutputFolder*. 

1. Verifica che nella cartella di output siano presenti i seguenti elementi:
   + Un oggetto di piccole dimensioni denominato `_SUCCESS`.
   + Un file CSV che inizia con il prefisso `part-` che contiene i risultati.

1. Scegli l'oggetto con i risultati, quindi scegli **Download** per salvare i risultati nel file system locale.

1. Apri i risultati nell'editor che preferisci. Il file di output elenca i primi dieci stabilimenti alimentari con il maggior numero di violazioni di tipo "red (rosso)". Il file di output mostra anche il numero totale di violazioni di tipo "red (rosso)" per ogni stabilimento.

   Di seguito è riportato un esempio di risultati `health_violations.py`.

   ```
   name, total_red_violations
   SUBWAY, 322
   T-MOBILE PARK, 315
   WHOLE FOODS MARKET, 299
   PCC COMMUNITY MARKETS, 251
   TACO TIME, 240
   MCDONALD'S, 177
   THAI GINGER, 153
   SAFEWAY INC #1508, 143
   TAQUERIA EL RINCONSITO, 134
   HIMITSU TERIYAKI, 128
   ```

Per ulteriori informazioni sull'output dei cluster Amazon EMR, consulta [Configurare una posizione per l'output del cluster Amazon EMR](emr-plan-output.md).

### (Facoltativo) Eseguire la connessione al cluster Amazon EMR in esecuzione
<a name="emr-getting-started-connect-to-cluster"></a>

Quando utilizzi Amazon EMR, potresti voler connetterti a un cluster in esecuzione per leggere i file di log, eseguire il debug del cluster o utilizzare strumenti CLI come la shell Spark. Amazon EMR consente di connetterti a un cluster utilizzando il protocollo Secure Shell (SSH). Questa sezione illustra come configurare SSH, connettersi al cluster e visualizzare i file di log per Spark. Per ulteriori informazioni sulla connessione a un cluster, consulta [Autenticazione nei nodi cluster Amazon EMR](emr-authenticate-cluster-connections.md).

#### Autorizza le connessioni SSH al cluster
<a name="emr-getting-started-restrict-ssh"></a>

Prima di connetterti al cluster, devi modificare i gruppi di sicurezza del cluster per autorizzare le connessioni SSH in entrata. I gruppi di sicurezza Amazon EC2 agiscono come firewall virtuali per controllare il traffico in entrata e uscita del cluster. Quando hai creato il cluster per questo tutorial, Amazon EMR ha creato i seguenti gruppi di sicurezza per tuo conto:

**ElasticMapReduce-padrone**  
Il gruppo di sicurezza gestito da Amazon EMR predefinito associato al nodo primario. In un cluster Amazon EMR, il nodo primario è un'istanza Amazon EC2 che gestisce il cluster.

**ElasticMapReduce-schiavo**  
Il gruppo di sicurezza predefinito associato ai nodi principali e attività.

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

**Per consentire l'accesso SSH a fonti attendibili per il gruppo di sicurezza primario con la console**

Per modificare i gruppi di sicurezza, devi disporre dell'autorizzazione per gestire i gruppi di sicurezza per il VPC in cui si trova il cluster. Per ulteriori informazioni, consulta [Modifica delle autorizzazioni per un utente](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html) e la [Policy di esempio](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_examples_ec2_securitygroups-vpc.html) che consente di gestire i gruppi di sicurezza EC2 nella *Guida per l'utente IAM*.

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 **EMR su EC2**, nel riquadro di navigazione a sinistra, scegli **Cluster** e quindi seleziona il cluster da aggiornare. Si apre la pagina dei dettagli del cluster. In questa pagina dovrebbe essere preselezionata la scheda **Properties** (Proprietà) .

1. In **Networking (Reti)** nella scheda **Properties** (Proprietà), seleziona la freccia accanto a **EC2 security groups (firewall)** (Gruppi di sicurezza EC2 [firewall]) per espandere questa sezione. In **Primary node** (Nodo primario), seleziona il collegamento al gruppo di sicurezza. Dopo avere completato i seguenti passaggi, puoi facoltativamente tornare a questo passaggio, scegliere **Core and task nodes** (Nodi core e attività) e ripetere i passaggi seguenti per consentire al client SSH di accedere ai nodi core e attività.

1. Si apre la console EC2. Scegli la scheda **Regole in entrata** e quindi **Modifica le regole in entrata**.

1. Verifica la presenza di una regola in entrata che consenta l'accesso pubblico con le seguenti impostazioni. Se esiste, scegli **Elimina** per rimuoverla.
   + **Tipo**

     SSH
   + **Porta**

     22
   + **Origine**

     Personalizzata 0.0.0.0/0
**avvertimento**  
Prima di dicembre 2020, il gruppo di sicurezza ElasticMapReduce -master disponeva di una regola preconfigurata per consentire il traffico in entrata sulla porta 22 da tutte le fonti. Questa regola è stata creata per semplificare le connessioni SSH iniziali al nodo principale. Ti consigliamo di rimuovere questa regola in entrata e limitare il traffico a origini affidabili.

1. Scorri fino alla fine dell'elenco di regole e seleziona **Aggiungi regola**.

1. Per **Tipo**, seleziona **SSH**. Selezionando SSH si inserisce in automatico **TCP** per **Protocollo** e **22** per **Intervallo porta**.

1. Per origine, seleziona **Il mio IP** per aggiungere in automatico il tuo indirizzo IP come indirizzo di origine. Puoi anche aggiungere un intervallo di indirizzi IP affidabili del client **Custom (Personalizzato)**, o creare regole aggiuntive per altri client. In molti ambienti di rete, gli indirizzi IP vengono allocati in modo dinamico, perciò, nel futuro, potrebbe essere necessario aggiornare gli indirizzi IP per client affidabili.

1. Scegli **Save** (Salva).

1. Facoltativamente, scegli **Nodi principali e di attività** dall'elenco e ripeti le fasi descritte in precedenza per consentire l'accesso SSH dei client ai nodi principali e attività.

------

#### Connect al cluster utilizzando AWS CLI
<a name="emr-getting-started-connect-ssh"></a>

A prescindere dal sistema operativo, è possibile creare una connessione SSH al cluster utilizzando la AWS CLI.

**Per connettersi al cluster e visualizzare i file di registro utilizzando il AWS CLI**

1. Utilizza il comando seguente per aprire una connessione SSH al cluster. Sostituisci *<mykeypair.key>* con il percorso completo e il nome del file della coppia di chiavi. Ad esempio, `C:\Users\<username>\.ssh\mykeypair.pem`.

   ```
   aws emr ssh --cluster-id <j-2AL4XXXXXX5T9> --key-pair-file <~/mykeypair.key>						
   ```

1. Navigare a `/mnt/var/log/spark` per accedere ai registri Spark sul nodo principale del cluster. Quindi visualizza i file in quella posizione. Per un elenco di file di log aggiuntivi sul nodo principale, consulta [Visualizzazione di file di log sul nodo primario](emr-manage-view-web-log-files.md#emr-manage-view-web-log-files-master-node).

   ```
   cd /mnt/var/log/spark
   ls
   ```

### Usa Amazon SageMaker AI Unified Studio per gestire il tuo cluster Amazon EMR
<a name="emr-getting-started-connect-to-cluster-sagemaker"></a>

 Amazon EMR su EC2 è anche un tipo di elaborazione supportato per Unified Studio. Amazon SageMaker AI Per informazioni su come utilizzare e [gestire EMR sulle risorse EC2 in Unified Studio, consulta Managing Amazon](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/managing-emr-on-ec2.html) EMR on EC2. Amazon SageMaker AI 

## Fase 3: pulizia delle risorse Amazon EMR
<a name="emr-getting-started-clean-up"></a>

### Terminazione di un cluster
<a name="emr-getting-started-stop-cluster"></a>

Ora che hai inviato il lavoro al cluster e visualizzato i risultati della tua PySpark applicazione, puoi terminare il cluster. La terminazione di un cluster interrompe tutti i costi Amazon EMR e le istanze Amazon EC2 associati.

Amazon EMR mantiene gratuitamente i metadati relativi al cluster per due mesi dopo la terminazione del cluster. I metadati archiviati ti aiutano [clonare il cluster](clone-console.md) per un nuovo lavoro o rivedere la configurazione del cluster a scopo di riferimento. I metadati *non* includono i dati che il cluster scrive in S3 o che sono archiviati in HDFS sul cluster. 

**Nota**  
La console di Amazon EMR non consente di eliminare un cluster dalla visualizzazione elenco in seguito alla terminazione del cluster. Un cluster terminato scompare dalla console quando Amazon EMR ne cancella i metadati. 

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

**Per terminare il cluster con la 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. Seleziona **Cluster**, quindi scegli il cluster da terminare.

1. Nel menu a discesa **Operazioni**, scegli **Termina cluster**.

1. Nella finestra di dialogo, scegli **Termina**. A seconda della configurazione del cluster, la terminazione potrebbe richiedere da 5 a 10 minuti. Per ulteriori informazioni sui cluster Amazon EMR, consulta la sezione [Termina un cluster Amazon EMR nello stato di avvio, in esecuzione o in attesa](UsingEMR_TerminateJobFlow.md).

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

**Per terminare il cluster con AWS CLI**

1. Avvia il processo di terminazione del cluster con il comando seguente. Sostituiscilo *<myClusterId>* con l'ID del cluster di esempio. Il comando non restituisce output.

   ```
   aws emr terminate-clusters --cluster-ids <myClusterId>
   ```

1. Per verificare che il processo di terminazione del cluster è in corso di esecuzione, controlla lo stato del cluster con il comando seguente.

   ```
   aws emr describe-cluster --cluster-id <myClusterId>									
   ```

   Di seguito è riportato un esempio di output in formato JSON. Lo `Status` del cluster dovrebbe passare da **`TERMINATING`** a **`TERMINATED`**. La terminazione potrebbe richiedere da 5 a 10 minuti a seconda della configurazione del cluster. Per ulteriori informazioni sulla terminazione di un cluster Amazon EMR, consulta [Termina un cluster Amazon EMR nello stato di avvio, in esecuzione o in attesa](UsingEMR_TerminateJobFlow.md).

   ```
   {
       "Cluster": {
           "Id": "j-xxxxxxxxxxxxx",
           "Name": "My Cluster Name",
           "Status": {
               "State": "TERMINATED",
               "StateChangeReason": {
                   "Code": "USER_REQUEST",
                   "Message": "Terminated by user request"
               }
           }
       }
   }
   ```

------

### Eliminazione di risorse S3
<a name="emr-getting-started-delete-bucket"></a>

Per evitare costi aggiuntivi, devi eliminare il bucket Amazon S3. L'eliminazione del bucket rimuove tutte le risorse di Amazon S3 per questo tutorial. Il bucket deve contenere:
+ La PySpark sceneggiatura
+ Il set di dati di input
+ La cartella dei risultati di output
+ La cartella dei file di log

Potrebbe essere necessario eseguire ulteriori passaggi per eliminare i file archiviati se PySpark lo script o l'output sono stati salvati in una posizione diversa.

**Nota**  
Il cluster deve essere terminato prima di eliminare il bucket. In caso contrario, potrebbe non essere consentito svuotare il bucket.

Per eliminare il bucket, segui le istruzioni in [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) nella *Guida per l'utente di Amazon Simple Storage Service*.

## Fasi successive
<a name="emr-gs-next-steps"></a>

Ora hai avviato il tuo primo cluster Amazon EMR dall'inizio alla fine. Hai inoltre completato processi EMR essenziali come la preparazione e l'invio di applicazioni di Big Data, la visualizzazione dei risultati e la terminazione di un cluster. 

Utilizza gli argomenti seguenti per ulteriori informazioni su come personalizzare il flusso di lavoro Amazon EMR.

### Valutazione delle applicazioni di big data per Amazon EMR
<a name="emr-gs-next-explore-apps"></a>

Scopri e confronta le applicazioni di big data che si possono installare in un cluster nella [Guida ai rilasci di Amazon EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-release-components.html). La Guida ai rilasci descrive in dettaglio ogni versione di EMR e include suggerimenti per l'utilizzo di framework come Spark e Hadoop su Amazon EMR.

### Pianificazione dell'hardware, della rete e della sicurezza del cluster
<a name="emr-gs-next-plan-clusters"></a>

In questo tutorial hai creato un cluster EMR semplice senza configurare opzioni avanzate. Le opzioni avanzate consentono di specificare i tipi di istanza Amazon EC2, la rete cluster e la sicurezza del cluster. Per ulteriori informazioni sulla pianificazione e sull'avvio di un cluster che soddisfi i tuoi requisiti, consulta [Pianifica, configura e avvia i cluster Amazon EMR](emr-plan.md) e [Sicurezza in Amazon EMR](emr-security.md).

### Gestione di cluster
<a name="emr-gs-next-manage-clusters"></a>

Immergiti nel lavoro con i cluster in esecuzione [Gestione dei cluster Amazon EMR](emr-manage.md). Per gestire un cluster, è possibile connettersi al cluster, eseguire il debug delle fasi e tenere traccia delle processi e l'integrità del cluster. Inoltre, puoi regolare le risorse del cluster in risposta alle richieste dei carichi di lavoro con [Dimensionamento gestito da EMR](emr-managed-scaling.md).

### Uso di un'interfaccia diversa
<a name="emr-gs-next-interfaces"></a>

Oltre alla console Amazon EMR, puoi gestire Amazon EMR utilizzando l'API del AWS Command Line Interface servizio Web o una delle tante supportate. AWS SDKs Per ulteriori informazioni, consulta [Interfacce di gestione](emr-overview-benefits.md#emr-what-tools).

Inoltre, puoi interagire in molti modi con le applicazioni installate nei cluster Amazon EMR. Alcune applicazioni come Apache Hadoop pubblicano interfacce Web visualizzabili. Per ulteriori informazioni, consulta [Visualizzazione di interfacce Web ospitate su cluster Amazon EMR](emr-web-interfaces.md).

### Consultazione del blog tecnico su EMR
<a name="emr-gs-next-browse-blogs"></a>

Per esempi dettagliati e discussioni tecniche approfondite sulle nuove caratteristiche di Amazon EMR, consulta il [Blog sui Big Data AWS](https://aws.amazon.com/blogs/big-data/tag/amazon-emr/).