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

# JupyterHub
<a name="emr-jupyterhub"></a>

[Jupyter Notebook](https://jupyter.org/) è un'applicazione Web open source che puoi utilizzare per creare e condividere documenti contenenti codice in tempo reale, equazioni, visualizzazioni e testo narrativo. [JupyterHub](https://jupyterhub.readthedocs.io/en/latest/)consente di ospitare più istanze di un server notebook Jupyter per utente singolo. Quando crei un cluster con JupyterHub, Amazon EMR crea un contenitore Docker sul nodo master del cluster. JupyterHub, tutti i componenti necessari per Jupyter e [Sparkmagic](https://github.com/jupyter-incubator/sparkmagic/blob/master/README.md) vengono eseguiti all'interno del contenitore.

Sparkmagic è una libreria di kernel che consente ai notebook Jupyter di interagire con [Apache Spark](https://aws.amazon.com/big-data/what-is-spark/) in esecuzione su Amazon EMR tramite [Apache Livy](emr-livy.md), che è un server REST per Spark. Spark e Apache Livy vengono installati automaticamente al momento della creazione di un cluster con JupyterHub. Il kernel Python 3 predefinito per Jupyter è disponibile insieme ai kernel PySpark 3 e Spark disponibili con Sparkmagic. PySpark Puoi utilizzare questi kernel per eseguire codice Spark ad-hoc e query SQL interattive utilizzando Python e Scala. Puoi installare kernel aggiuntivi all'interno del container Docker manualmente. Per ulteriori informazioni, consulta [Installazione di kernel e librerie aggiuntive](emr-jupyterhub-install-kernels-libs.md).

Il diagramma seguente illustra i componenti di JupyterHub Amazon EMR con i metodi di autenticazione corrispondenti per gli utenti di notebook e l'amministratore. Per ulteriori informazioni, consulta [Aggiunta di utenti e amministratori Jupyter Notebook](emr-jupyterhub-user-access.md).

![\[JupyterHub architecture on EMR showing user authentication and component interactions.\]](http://docs.aws.amazon.com/it_it/emr/latest/ReleaseGuide/images/jupyter-arch.png)


La tabella seguente elenca la versione JupyterHub inclusa nell'ultima release della serie Amazon EMR 7.x, insieme ai componenti con cui viene installato Amazon EMR. JupyterHub

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


**JupyterHub informazioni sulla versione per emr-7.12.0**  

| Etichetta di rilascio di Amazon EMR | JupyterHub versione | Componenti installati con JupyterHub | 
| --- | --- | --- | 
| emr-7.12.0 | JupyterHub 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 

La tabella seguente elenca la versione JupyterHub inclusa nell'ultima release della serie Amazon EMR 6.x, insieme ai componenti con cui viene installato Amazon EMR. JupyterHub

[Per la versione dei componenti installati con questa versione, consulta JupyterHub Versioni dei componenti della release 6.15.0.](emr-6150-release.md)


**JupyterHub informazioni sulla versione per emr-6.15.0**  

| Etichetta di rilascio di Amazon EMR | JupyterHub versione | Componenti installati con JupyterHub | 
| --- | --- | --- | 
| emr-6.15.0 | JupyterHub 1.5.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 

La tabella seguente elenca la versione JupyterHub inclusa nell'ultima release della serie Amazon EMR 5.x, insieme ai componenti con cui viene installato Amazon EMR. JupyterHub

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


**JupyterHub informazioni sulla versione per emr-5.36.2**  

| Etichetta di rilascio di Amazon EMR | JupyterHub versione | Componenti installati con JupyterHub | 
| --- | --- | --- | 
| emr-5.36.2 | JupyterHub 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 

Il kernel Python 3 incluso in JupyterHub Amazon EMR è 3.6.4.

Le librerie installate all'interno del container `jupyterhub` possono variare tra versioni del rilascio Amazon EMR e versioni dell'AMI Amazon EC2.

**Per elencare le librerie installate utilizzando `conda`**
+ Eseguire il seguente comando sulla riga di comando del nodo master:

  ```
  sudo docker exec jupyterhub bash -c "conda list"
  ```

**Per elencare le librerie installate utilizzando `pip`**
+ Eseguire il seguente comando sulla riga di comando del nodo master:

  ```
  sudo docker exec jupyterhub bash -c "pip freeze"
  ```

**Topics**
+ [Crea un cluster con JupyterHub](emr-jupyterhub-launch.md)
+ [Considerazioni JupyterHub sull'utilizzo su Amazon EMR](emr-jupyterhub-considerations.md)
+ [Configurazione JupyterHub](emr-jupyterhub-configure.md)
+ [Configurazione della persistenza per i notebook in Amazon S3](emr-jupyterhub-s3.md)
+ [Connessione al nodo master e ai server notebook](emr-jupyterhub-connect.md)
+ [JupyterHub configurazione e amministrazione](emr-jupyterhub-administer.md)
+ [Aggiunta di utenti e amministratori Jupyter Notebook](emr-jupyterhub-user-access.md)
+ [Installazione di kernel e librerie aggiuntive](emr-jupyterhub-install-kernels-libs.md)
+ [JupyterHub cronologia delle versioni](JupyterHub-release-history.md)

# Crea un cluster con JupyterHub
<a name="emr-jupyterhub-launch"></a>

Puoi creare un cluster Amazon EMR JupyterHub utilizzando Console di gestione AWS AWS Command Line Interface, o l'API Amazon EMR. Assicurati che il cluster non venga creato con l'opzione per terminare automaticamente dopo il completamento delle fasi (opzione `--auto-terminate` in AWS CLI). Inoltre, assicurati che gli amministratori e gli utenti di notebook siano in grado di accedere alla coppia di chiavi utilizzata durante la creazione del cluster. Per ulteriori informazioni, consulta la sezione relativa all'[Utilizzo di una coppia di chiavi per le credenziali SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-access-ssh.html) nella *Guida alla gestione di Amazon EMR*.

## Crea un cluster JupyterHub utilizzando la console
<a name="emr-jupyterhub-launch-console"></a>

Utilizza la seguente procedura per creare un cluster con JupyterHub installato utilizzando **Advanced Options** nella console Amazon EMR.

**Per creare un cluster Amazon EMR con JupyterHub installazione tramite la console Amazon EMR**

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. In **Software Configuration (Configurazione del software)**:
   + Per **Release**, seleziona emr-5.36.2 e scegli. JupyterHub
   + Se usi Spark, per utilizzare il AWS Glue Data Catalog come metastore per Spark SQL, seleziona **Use** for Spark table metadata. Per ulteriori informazioni, consulta [Usa il catalogo AWS Glue Data Catalog con Spark su Amazon EMR](emr-spark-glue.md).
   + Per **Edit software settings (Modifica impostazioni software)**, scegliere **Enter configuration (Immetti configurazione)** e specificare i valori di configurazione o scegliere **Load JSON from S3 (Carica JSON da S3)** e specificare un file di configurazione JSON. Per ulteriori informazioni, consulta [Configurazione JupyterHub](emr-jupyterhub-configure.md).

1. In **Add steps (optional) (Aggiungi fasi (opzionale))** configurare le fasi da eseguire quando il cluster viene creato, accertarsi che **Auto-terminate cluster after the last step is completed (Una volta completata la fase, termina automaticamente il cluster)** non sia selezionata e scegliere **Next (Successivo)**.

1. Scegliere le opzioni **Hardware Configuration (Configurazione hardware)**, **Next (Successivo)**. Per ulteriori informazioni, consulta la sezione relativa alla [Configurazione di hardware e reti cluster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-instances.html) nella *Guida alla gestione di Amazon EMR*.

1. Scegliere opzioni per **General Cluster Settings (Impostazioni generali del cluster)**, **Next (Successivo)**.

1. Scegliere **Security Options (Opzioni di protezione)**, specificando un coppia di chiavi e scegliere **Create Cluster (Crea cluster)**.

## Crea un cluster usando il JupyterHub AWS CLI
<a name="emr-jupyterhub-launch-cli"></a>

Per avviare un cluster con JupyterHub, usa il `aws emr create-cluster` comando e, per l'`--applications`opzione, specifica`Name=JupyterHub`. L'esempio seguente avvia un JupyterHub cluster su Amazon EMR con due istanze EC2 (un'istanza master e un'istanza core). Inoltre, il debug è abilitato, con i log archiviati nel percorso Amazon S3 come specificato da `--log-uri`. La coppia di chiavi specificata fornisce l'accesso a istanze Amazon EC2 nel cluster.

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

```
aws emr create-cluster --name="MyJupyterHubCluster" --release-label emr-5.36.2 \
--applications Name=JupyterHub --log-uri s3://amzn-s3-demo-bucket/MyJupyterClusterLogs \
--use-default-roles --instance-type m5.xlarge --instance-count 2 --ec2-attributes KeyName=MyKeyPair
```

# Considerazioni JupyterHub sull'utilizzo su Amazon EMR
<a name="emr-jupyterhub-considerations"></a>

Considera quanto segue quando utilizzi JupyterHub Amazon EMR.
+ 
**avvertimento**  
I notebook e i file utente vengono salvati nel file system sul nodo master. Si tratta di uno storage temporaneo che non viene mantenuto attraverso la terminazione del cluster. Quando un cluster viene terminato, questi dati vengono persi se non si esegue un backup. Ti consigliamo di pianificare l'esecuzione di backup regolari utilizzando processi `cron` o un altro mezzo idoneo per l'applicazione.  
Inoltre, modifiche di configurazione apportate all'interno del container potrebbero non persistere in caso di riavvio del container. Ti consigliamo di creare uno script o automatizzare la configurazione del container in modo da riprodurre le personalizzazioni più facilmente.
+ L'autenticazione Kerberos che è stata configurata utilizzando una configurazione di sicurezza Amazon EMR non è supportata.
+ [OAuthenticator](https://github.com/jupyterhub/oauthenticator) non è supportato.

# Configurazione JupyterHub
<a name="emr-jupyterhub-configure"></a>

Puoi personalizzare la configurazione dei notebook JupyterHub su Amazon EMR e dei singoli utenti connettendoti al nodo master del cluster e modificando i file di configurazione. Dopo aver modificato i valori, riavvia il container `jupyterhub`.

Modifica le proprietà nei seguenti file per configurare JupyterHub e personalizzare i notebook Jupyter:
+ `jupyterhub_config.py`: per impostazione predefinita, questo file viene salvato nella directory `/etc/jupyter/conf/` sul nodo master. [Per ulteriori informazioni, consulta Nozioni di base sulla configurazione nella documentazione.](http://jupyterhub.readthedocs.io/en/latest/getting-started/config-basics.html) JupyterHub 
+ `jupyter_notebook_config.py`: questo file viene salvato nella directory `/etc/jupyter/` per impostazione predefinita e copiato nel container `jupyterhub` come predefinito. Per ulteriori informazioni, consulta la sezione relativa al [file di configurazione e alle opzioni della riga di comando](https://jupyter-notebook.readthedocs.io/en/5.7.4/config.html) nella documentazione di Jupyter Notebook.

Puoi anche utilizzare la classificazione di configurazione `jupyter-sparkmagic-conf` per personalizzare Sparkmagic, che consente di aggiornare i valori nel file `config.json` per Sparkmagic. Per ulteriori informazioni sulle impostazioni disponibili, consulta [example\$1config.json](https://github.com/jupyter-incubator/sparkmagic/blob/master/sparkmagic/example_config.json) su. GitHub Per ulteriori informazioni sull'utilizzo delle classificazioni di configurazione con le applicazioni in Amazon EMR, consulta [Configurazione delle applicazioni](emr-configure-apps.md).

L'esempio seguente avvia un cluster utilizzando, facendo riferimento al file per le impostazioni di classificazione della AWS CLI configurazione Sparkmagic. `MyJupyterConfig.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 (^).

```
aws emr create-cluster --use-default-roles --release-label emr-5.14.0 \
--applications Name=Jupyter --instance-type m4.xlarge --instance-count 3 \
--ec2-attributes KeyName=MyKey,SubnetId=subnet-1234a5b6 --configurations file://MyJupyterConfig.json
```

Di seguito sono mostrati i contenuti di esempio di `MyJupyterConfig.json`:

```
[
    {
    "Classification":"jupyter-sparkmagic-conf",
    "Properties": {
      "kernel_python_credentials" : "{\"username\":\"diego\",\"base64_password\":\"mypass\",\"url\":\"http:\/\/localhost:8998\",\"auth\":\"None\"}"
      }
    }
]
```

**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).

# Configurazione della persistenza per i notebook in Amazon S3
<a name="emr-jupyterhub-s3"></a>

Puoi configurare un JupyterHub cluster in Amazon EMR in modo che i notebook salvati da un utente rimangano in Amazon S3, al di fuori dello storage temporaneo sulle istanze EC2 del cluster.

La persistenza di Amazon S3 viene specificata utilizzando la classificazione di configurazione `jupyter-s3-conf` al momento della creazione di un cluster. Per ulteriori informazioni, consulta [Configurazione delle applicazioni](emr-configure-apps.md).

Oltre ad abilitare la persistenza di Amazon S3 utilizzando la proprietà `s3.persistence.enabled`, è possibile specificare un bucket in Amazon S3 in cui i notebook vengono salvati utilizzando la proprietà `s3.persistence.bucket`. I notebook per ciascun utente vengono salvati in una cartella `jupyter/jupyterhub-user-name` nel bucket specificato. Il bucket deve esistere già in Amazon S3 e il ruolo per il profilo dell'istanza EC2 specificato al momento della creazione del cluster deve disporre delle autorizzazioni per il bucket (per impostazione predefinita, il ruolo è `EMR_EC2_DefaultRole`). Per ulteriori informazioni, consulta [Configurare i ruoli IAM per le autorizzazioni di Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html) ai servizi. AWS 

Quando avvii un nuovo cluster utilizzando le stesse proprietà di classificazione di configurazione, gli utenti possono aprire i notebook con i contenuti dalla posizione salvata.

Tieni presente che l'importazione del file sotto forma di moduli in un notebook quando Amazon S3 è abilitato comporterà il caricamento dei file su Amazon S3. Quando importi file senza abilitare la persistenza di Amazon S3, questi vengono caricati nel tuo contenitore. JupyterHub 

L'esempio seguente abilita la persistenza di Amazon S3. I notebook salvati dagli utenti vengono salvati nella cartella `s3://MyJupyterBackups/jupyter/jupyterhub-user-name` per ciascun utente, dove `jupyterhub-user-name` è un nome utente, ad esempio `diego`.

```
[
    {
        "Classification": "jupyter-s3-conf",
        "Properties": {
            "s3.persistence.enabled": "true",
            "s3.persistence.bucket": "MyJupyterBackups"
        }
    }
]
```

# Connessione al nodo master e ai server notebook
<a name="emr-jupyterhub-connect"></a>

JupyterHub gli amministratori e gli utenti di notebook devono connettersi al nodo master del cluster utilizzando un tunnel SSH e quindi connettersi alle interfacce Web servite dal JupyterHub nodo master. Per ulteriori informazioni sulla configurazione di un tunnel SSH e l'utilizzo del tunnel per effettuare il proxy delle connessioni Web, consulta [Connessione al cluster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node.html) nella *Guida alla gestione di Amazon EMR*.

Per impostazione predefinita, JupyterHub su Amazon EMR è disponibile tramite la **porta 9443** sul nodo master. Il JupyterHub proxy interno serve anche le istanze dei notebook tramite la porta 9443. JupyterHub e alle interfacce web di Jupyter è possibile accedere utilizzando un URL con il seguente schema:

**https: *MasterNodeDNS*** **//:9443**

Puoi specificare una porta differente utilizzando la proprietà `c.JupyterHub.port` nel file `jupyterhub_config.py`. Per ulteriori informazioni, consulta [Nozioni di base sulla rete](http://jupyterhub.readthedocs.io/en/latest/getting-started/networking-basics.html) nella documentazione. JupyterHub 

Per impostazione predefinita, JupyterHub su Amazon EMR utilizza un certificato autofirmato per la crittografia SSL tramite HTTPS. Agli utenti viene chiesto di considerare affidabile il certificato autofirmato quando si collegano. Puoi utilizzare un certificato affidabile e chiavi di tua proprietà. Sostituisci il file di certificato predefinito, `server.crt`, e il file della chiave `server.key` nella directory `/etc/jupyter/conf/` sul nodo master con file di certificato e di chiave personali. Utilizza le proprietà `c.JupyterHub.ssl_key` e `c.JupyterHub.ssl_cert` nel file `jupyterhub_config.py` per specificare i materiali SSL. Per ulteriori informazioni, consulta [Impostazioni di sicurezza nella documentazione](https://jupyterhub.readthedocs.io/en/latest/tutorial/getting-started/security-basics.html). JupyterHub Dopo aver aggiornato `jupyterhub_config.py`, riavvia il container.

# JupyterHub configurazione e amministrazione
<a name="emr-jupyterhub-administer"></a>

JupyterHub e i relativi componenti vengono eseguiti all'interno di un contenitore Docker denominato `jupyterhub` che esegue il sistema operativo Ubuntu. Esistono diversi modi per amministrare i componenti in esecuzione all'interno del container.

**avvertimento**  
Le personalizzazioni eseguite all'interno del container potrebbero non persistere in caso di riavvio del container. Ti consigliamo di creare uno script o automatizzare la configurazione del container in modo da riprodurre le personalizzazioni più facilmente.

## Amministrazione mediante la riga di comando
<a name="emr-jupyterhub-administer-cli"></a>

In caso di connessione al nodo master tramite SSH, puoi inviare comandi utilizzando l'interfaccia a riga di comando (CLI) del Docker e specificando il container per nome (`jupyterhub`) o ID. Ad esempio, `sudo docker exec jupyterhub command` esegue i comandi riconosciuti dal sistema operativo o un'applicazione in esecuzione all'interno del container. Puoi utilizzare questo metodo per aggiungere utenti al sistema operativo e installare applicazioni e librerie aggiuntive all'interno del container Docker. Ad esempio, l'immagine del container predefinito include Conda per installazione di pacchetti, pertanto puoi eseguire il comando seguente sulla riga di comando del nodo master per installare un'applicazione, Keras, all'interno del container:

```
sudo docker exec jupyterhub conda install keras
```

## Amministrazione inviando fasi
<a name="emr-jupyterhub-administer-steps"></a>

Le fasi sono un modo per inviare lavori a un cluster. Puoi inviare fasi all'avvio di un cluster o puoi inviare fasi a un cluster in esecuzione. I comandi eseguiti sulla riga di comando possono essere inviati come fasi mediante `command-runner.jar`. Per ulteriori informazioni, consulta la sezione relativa all'[Utilizzo di fasi mediante la CLI e la console](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-work-with-steps.html) nella *Guida alla gestione di Amazon EMR* e [Eseguire comandi e script su un cluster Amazon EMR](emr-commandrunner.md).

Ad esempio, puoi usare il seguente AWS CLI comando su un computer locale per installare Keras nello stesso modo in cui lo hai fatto dalla riga di comando del nodo master nell'esempio precedente:

```
aws emr add-steps --cluster-id MyClusterID --steps Name="Command Runner",Jar="command-runner.jar",Args="/usr/bin/sudo","/usr/bin/docker","exec","jupyterhub","conda","install","keras"
```

Inoltre, puoi creare uno script di una sequenza di fasi, caricare lo script in Amazon S3, quindi utilizzare `script-runner.jar` per eseguire lo script durante la creazione del cluster o l'aggiunta dello script come una fase. Per ulteriori informazioni, consulta [Eseguire comandi e script su un cluster Amazon EMR](emr-commandrunner.md). Per vedere un esempio, consulta [Esempio: Script bash per aggiungere più utenti](emr-jupyterhub-pam-users.md#emr-jupyterhub-script-multuser).

## Amministrazione tramite REST APIs
<a name="emr-jupyterhub-administer-rest"></a>

Jupyter e JupyterHub il proxy HTTP JupyterHub forniscono REST APIs che è possibile utilizzare per inviare richieste. Per inviare richieste a JupyterHub, è necessario passare un token API con la richiesta. Puoi utilizzare il comando `curl` dalla riga di comando del nodo master per eseguire i comandi REST. Per maggiori informazioni, consulta le seguenti risorse:
+ [Utilizzo JupyterHub dell'API REST](http://jupyterhub.readthedocs.io/en/latest/reference/rest.html) nella documentazione di JupyterHub, che include le istruzioni per la generazione di token API
+ API del [server Jupyter Notebook attiva](https://github.com/jupyter/jupyter/wiki/Jupyter-Notebook-Server-API) GitHub
+ [configurable-http-proxy](https://github.com/jupyterhub/configurable-http-proxy)su GitHub

L'esempio seguente dimostra l'utilizzo dell'API REST per JupyterHub ottenere un elenco di utenti. Il comando passa un token di amministrazione generato in precedenza e utilizza la porta predefinita, 9443, for JupyterHub, reindirizzando l'output a [jq](https://stedolan.github.io/jq/) per una visualizzazione più semplice:

```
curl -XGET -s -k https://$HOST:9443/hub/api/users \
-H "Authorization: token $admin_token" | jq .
```

# Aggiunta di utenti e amministratori Jupyter Notebook
<a name="emr-jupyterhub-user-access"></a>

È possibile utilizzare uno dei due metodi con cui gli utenti possono autenticarsi in JupyterHub modo che possano creare notebook e, facoltativamente, amministrarli. JupyterHub Il metodo più semplice consiste nell'utilizzare il modulo di autenticazione collegabile ( JupyterHubPAM). Inoltre, JupyterHub su Amazon EMR supporta il [plug-in di autenticazione LDAP JupyterHub per](https://github.com/jupyterhub/ldapauthenticator/) ottenere le identità degli utenti da un server LDAP, come un server Microsoft Active Directory. Istruzioni ed esempi per l'aggiunta di utenti con ogni metodo di autenticazione vengono forniti in questa sezione.

JupyterHub su Amazon EMR ha un utente predefinito con autorizzazioni di amministratore. Il nome utente è `jovyan` e la password è `jupyter`. Ti consigliamo di sostituire l'utente con un altro che dispone di autorizzazioni amministrative. È possibile eseguire questa operazione utilizzando una fase della creazione del cluster, oppure collegandosi al nodo master quando il cluster è in esecuzione.

**Topics**
+ [Utilizzo dell'autenticazione PAM](emr-jupyterhub-pam-users.md)
+ [Utilizzo dell'autenticazione LDAP](emr-jupyterhub-ldap-users.md)
+ [Rappresentazione dell'utente](emr-jupyterhub-user-impersonation.md)

# Utilizzo dell'autenticazione PAM
<a name="emr-jupyterhub-pam-users"></a>

La creazione di utenti PAM in JupyterHub Amazon EMR è un processo in due fasi. La prima fase è aggiungere utenti al sistema operativo in esecuzione nel container `jupyterhub` sul nodo master e aggiungere una home directory utente corrispondente per ogni utente. Il secondo passaggio consiste nell'aggiungere questi utenti del sistema operativo come JupyterHub utenti, un processo noto come whitelisting in. JupyterHub Una volta aggiunto, un JupyterHub utente può connettersi all' JupyterHub URL e fornire le credenziali del sistema operativo per l'accesso.

Quando un utente accede, JupyterHub apre l'istanza del server notebook per quell'utente, che viene salvata nella home directory dell'utente sul nodo master, ovvero. `/var/lib/jupyter/home/username` Se non esiste un'istanza del server notebook, JupyterHub genera un'istanza di notebook nella home directory dell'utente. Le sezioni seguenti mostrano come aggiungere utenti singolarmente al sistema operativo e a JupyterHub, seguite da uno script bash rudimentale che aggiunge più utenti.

## Aggiunta di un utente del sistema operativo al container
<a name="emr-jupyterhub-system-user"></a>

Nell'esempio seguente viene utilizzato innanzitutto il comando [useradd](https://linux.die.net/man/8/useradd) all'interno del container per aggiungere un singolo utente, diego, e creare una home directory per tale utente. Il secondo comando utilizza [chpasswd](https://linux.die.net/man/8/chpasswd) per stabilire una password di diego per questo utente. I comandi vengono eseguiti sulla riga di comando del nodo master durante la connessione mediante SSH. Puoi anche eseguire questi comandi utilizzando una fase come descritto in precedenza in [Amministrazione inviando fasi](emr-jupyterhub-administer.md#emr-jupyterhub-administer-steps).

```
sudo docker exec jupyterhub useradd -m -s /bin/bash -N diego
sudo docker exec jupyterhub bash -c "echo diego:diego | chpasswd"
```

## Aggiungere un utente JupyterHub
<a name="emr-jupyterhub-jupyterhub-user"></a>

Puoi utilizzare il pannello di **amministrazione** JupyterHub o l'API REST per aggiungere utenti e amministratori o solo utenti.

**Per aggiungere utenti e amministratori utilizzando il pannello di amministrazione in JupyterHub**

1. Connect al master node tramite SSH e accedi a https: //:9443 *MasterNodeDNS* con un'identità con autorizzazioni di amministratore.

1. Scegliere **Control Panel (Pannello di controllo)**, **Admin (Amministratore)**.

1. Scegliere **User (Utente)**, **Add Users (Aggiungi utenti)** o scegliere **Admin (Amministratore)**, **Add Admins (Aggiungi amministratori)**.

**Per aggiungere un utente utilizzando la REST API**

1. Connettersi al nodo master mediante SSH e utilizzare il comando seguente sul nodo master o eseguire il comando come una fase.

1. Acquisisci un token amministrativo per effettuare richieste API e sostituiscilo *AdminToken* nel passaggio successivo con quel token.

1. Utilizzate il seguente comando, sostituendolo *UserName* con un utente del sistema operativo creato all'interno del contenitore.

   ```
   curl -XPOST -H "Authorization: token AdminToken" "https://$(hostname):9443/hub/api/users/UserName
   ```

**Nota**  
Verrai aggiunto automaticamente come utente JupyterHub non amministratore quando accedi all'interfaccia JupyterHub web per la prima volta.

## Esempio: Script bash per aggiungere più utenti
<a name="emr-jupyterhub-script-multuser"></a>

Il seguente script bash di esempio collega i passaggi precedenti di questa sezione per creare più JupyterHub utenti. Lo script può essere eseguito direttamente sul nodo master o può essere caricato in Amazon S3 e, successivamente, eseguito come fase.

Il primo script stabilisce una serie di nomi utente e utilizza il comando `jupyterhub token` per creare un token API per l'amministratore predefinito, jovyan. Quindi crea un utente del sistema operativo nel container `jupyterhub` per ogni utente, assegnando a ciascuno una password iniziale che è uguale al relativo nome utente. Infine, chiama l'operazione API REST per creare ogni utente in JupyterHub. Il token generato in precedenza nello script viene passato ed la risposta REST viene reindirizzata a `jq` per facilitare la visualizzazione.

```
# Bulk add users to container and JupyterHub with temp password of username
set -x
USERS=(shirley diego ana richard li john mary anaya)
TOKEN=$(sudo docker exec jupyterhub /opt/conda/bin/jupyterhub token jovyan | tail -1)
for i in "${USERS[@]}"; 
do 
   sudo docker exec jupyterhub useradd -m -s /bin/bash -N $i
   sudo docker exec jupyterhub bash -c "echo $i:$i | chpasswd"
   curl -XPOST --silent -k https://$(hostname):9443/hub/api/users/$i \
 -H "Authorization: token $TOKEN" | jq
done
```

Salva lo script in un percorso in Amazon S3, ad esempio `s3://amzn-s3-demo-bucket/createjupyterusers.sh`. Quindi puoi utilizzare `script-runner.jar` per eseguirlo come una fase.

### Esempio: Esecuzione dello script durante la creazione di un cluster (AWS CLI)
<a name="emr-jupyterhub-multuser-createcluster"></a>

**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="MyJupyterHubCluster" --release-label emr-5.36.2 \
--applications Name=JupyterHub --log-uri s3://amzn-s3-demo-bucket/MyJupyterClusterLogs \
--use-default-roles --instance-type m5.xlarge --instance-count 2 --ec2-attributes KeyName=MyKeyPair \
--steps Type=CUSTOM_JAR,Name=CustomJAR,ActionOnFailure=CONTINUE,\
Jar=s3://region.elasticmapreduce/libs/script-runner/script-runner.jar,Args=["s3://amzn-s3-demo-bucket/createjupyterusers.sh"]
```

### Esecuzione dello script su un cluster esistente (AWS CLI)
<a name="emr-jupyterhub-multuser-runningcluster"></a>

**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 add-steps --cluster-id j-XXXXXXXX --steps Type=CUSTOM_JAR,\
Name=CustomJAR,ActionOnFailure=CONTINUE,\
Jar=s3://region.elasticmapreduce/libs/script-runner/script-runner.jar,Args=["s3://amzn-s3-demo-bucket/createjupyterusers.sh"]
```

# Utilizzo dell'autenticazione LDAP
<a name="emr-jupyterhub-ldap-users"></a>

LDAP è un protocollo di applicazioni per inviare query e modificare oggetti che corrispondono a risorse quali utenti e computer archiviati in un provider di servizi di directory compatibile con LDAP, ad esempio Active Directory o un server OpenLDAP. Puoi utilizzare il [plug-in di autenticazione LDAP per with JupyterHub su JupyterHub Amazon EMR per](https://github.com/jupyterhub/ldapauthenticator/) utilizzare LDAP per l'autenticazione degli utenti. Il plugin gestisce sessioni di accesso per utenti LDAP e fornisce informazioni utente a Jupyter. Ciò consente agli utenti di connettersi ai notebook utilizzando JupyterHub le credenziali per le loro identità archiviate in un server compatibile con LDAP.

I passaggi di questa sezione illustrano i seguenti passaggi per configurare e abilitare LDAP utilizzando il plug-in LDAP Authenticator per. JupyterHub Eseguire le fasi mentre si è connessi alla riga di comando del nodo master. Per ulteriori informazioni, consulta [Connessione al nodo master e ai server notebook](emr-jupyterhub-connect.md).

1. Crea un file di configurazione LDAP con informazioni sul server LDAP, ad esempio l'indirizzo IP host, la porta, i nomi di binding e così via.

1. Modifica `/etc/jupyter/conf/jupyterhub_config.py` per abilitare LDAP Authenticator Plugin per JupyterHub.

1. Crea ed esegui uno script che configura LDAP all'interno del container `jupyterhub`.

1. Interroga LDAP per gli utenti, quindi crea le home directory all'interno del contenitore per ogni utente. JupyterHub richiede le home directory per ospitare i notebook.

1. Esegui uno script che si riavvia JupyterHub

**Importante**  
Prima di configurare LDAP, verifica l'infrastruttura di rete per garantire che il server LDAP e il nodo master del cluster siano in grado di comunicare come richiesto. TLS utilizza in genere la porta 389 su una connessione TCP semplice. Se la connessione LDAP utilizza SSL, la porta TCP nota per SSL è 636.

## Creazione del file di configurazione LDAP
<a name="emr-jupyterhub-ldap-config"></a>

Nell'esempio seguente vengono utilizzati i seguenti valori di configurazione del segnaposto. Sostituiscili con i parametri che soddisfano l'implementazione.
+ Il server LDAP esegue la versione 3 ed è disponibile sulla porta 389. Questa è la porta non SSL standard per LDAP.
+ Il nome distinto di base (DN) è `dc=example, dc=org`.

Utilizza un editor di testo per creare il file [ldap.conf](http://manpages.ubuntu.com/manpages/bionic/man5/ldap.conf.5.html), con contenuti simili ai seguenti. Utilizza valori appropriate per l'implementazione LDAP. *host*Sostituiscilo con l'indirizzo IP o il nome host risolvibile del tuo server LDAP.

```
base dc=example,dc=org
uri ldap://host
ldap_version 3
binddn cn=admin,dc=example,dc=org
bindpw admin
```

## Abilita il plug-in LDAP Authenticator per JupyterHub
<a name="emr-jupyterhub-ldap-plugin"></a>

Utilizza un editor di testo per modificare il file `/etc/jupyter/conf/jupyterhub_config.py` e aggiungere proprietà [ldapauthenticator](https://github.com/jupyterhub/ldapauthenticator) simili alle seguenti. Sostituire *host* con l'indirizzo IP o il nome host risolvibile del server LDAP. L'esempio presuppone che gli oggetti utente si trovino all'interno di un'unità organizzativa (ou) denominata *people* e utilizzi i componenti del nome distinto definiti in precedenza utilizzando. `ldap.conf`

```
c.JupyterHub.authenticator_class = 'ldapauthenticator.LDAPAuthenticator'
c.LDAPAuthenticator.use_ssl = False
c.LDAPAuthenticator.server_address = 'host' 
c.LDAPAuthenticator.bind_dn_template = 'cn={username},ou=people,dc=example,dc=org'
```

## Configurazione di LDAP all'interno del container
<a name="emr-jupyterhub-ldap-container"></a>

Utilizza un editor di testo per creare uno script bash con il seguente contenuto:

```
#!/bin/bash

# Uncomment the following lines to install LDAP client libraries only if
# using Amazon EMR release version 5.14.0. Later versions install libraries by default.
# sudo docker exec jupyterhub bash -c "sudo apt-get update"
# sudo docker exec jupyterhub bash -c "sudo apt-get -y install libnss-ldap libpam-ldap ldap-utils nscd"
 
# Copy ldap.conf
sudo docker cp ldap.conf jupyterhub:/etc/ldap/
sudo docker exec jupyterhub bash -c "cat /etc/ldap/ldap.conf"
 
# configure nss switch
sudo docker exec jupyterhub bash -c "sed -i 's/\(^passwd.*\)/\1 ldap/g' /etc/nsswitch.conf"
sudo docker exec jupyterhub bash -c "sed -i 's/\(^group.*\)/\1 ldap/g' /etc/nsswitch.conf"
sudo docker exec jupyterhub bash -c "sed -i 's/\(^shadow.*\)/\1 ldap/g' /etc/nsswitch.conf"
sudo docker exec jupyterhub bash -c "cat /etc/nsswitch.conf"
 
# configure PAM to create home directories
sudo docker exec jupyterhub bash -c "echo 'session required        pam_mkhomedir.so skel=/etc/skel umask=077' >> /etc/pam.d/common-session"
sudo docker exec jupyterhub bash -c "cat /etc/pam.d/common-session"
 
# restart nscd service
sudo docker exec jupyterhub bash -c "sudo service nscd restart"
 
# Test
sudo docker exec jupyterhub bash -c "getent passwd"

# Install ldap plugin
sudo docker exec jupyterhub bash -c "pip install jupyterhub-ldapauthenticator"
```

Salva lo script nel nodo master, quindi eseguilo dalla riga di comando del nodo master. Ad esempio, con lo script salvato come `configure_ldap_client.sh`, rendi il file eseguibile:

```
chmod +x configure_ldap_client.sh
```

Ed esegui lo script:

```
./configure_ldap_client.sh
```

## Aggiunta di attributi ad Active Directory
<a name="emr-jupyterhub-ldap-adproperties"></a>

Per trovare ogni utente e creare la voce appropriata nel database, il contenitore JupyterHub docker richiede le seguenti proprietà UNIX per l'oggetto utente corrispondente in Active Directory. Per ulteriori informazioni, vedere la sezione *Come posso continuare a modificare gli attributi GID/UID RFC 2307 ora che il plug-in Unix Attributes non è più disponibile per lo snap-in MMC Active Directory Users* and Computers? nell'articolo [Chiarimenti sullo stato della gestione delle identità per Unix (IDMU) e sul ruolo del server NIS nell'anteprima tecnica di Windows Server 2016 e](https://blogs.technet.microsoft.com/activedirectoryua/2016/02/09/identity-management-for-unix-idmu-is-deprecated-in-windows-server/) oltre.
+ `homeDirectory`

  Questo è il percorso alla home directory dell'utente, in genere `/home/username`.
+ `gidNumber`

  Si tratta di un valore maggiore di 60000 che non è già utilizzato da un altro utente. Seleziona il file `etc/passwd` per i gid in uso.
+ `uidNumber`

  Si tratta di un valore maggiore di 60000 che non è già utilizzato da un altro gruppo. Seleziona il file `etc/group` per gli uid in uso.
+ `uid`

  È lo stesso di. *username*

## Creazione di home directory dell'utente
<a name="emr-jupyterhub-ldap-directories"></a>

JupyterHub necessita di home directory all'interno del contenitore per autenticare gli utenti LDAP e archiviare i dati delle istanze. Nell'esempio seguente vengono illustrati due utenti, *shirley* e *diego*, nella directory LDAP.

Il primo passaggio consiste nell'interrogare il server LDAP per le informazioni sull'ID utente e sull'ID di gruppo di ciascun utente utilizzando [ldapsearch](http://manpages.ubuntu.com/manpages/xenial/man1/ldapsearch.1.html), come mostrato nell'esempio seguente, sostituendolo *host* con l'indirizzo IP o il nome host risolvibile del server LDAP:

```
ldapsearch -x -H ldap://host \
 -D "cn=admin,dc=example,dc=org" \
 -w admin \
 -b "ou=people,dc=example,dc=org" \
 -s sub \
 "(objectclass=*)" uidNumber gidNumber
```

Il comando `ldapsearch` restituisce una risposta in formato LDIF il cui aspetto è simile al seguente per gli utenti *shirley* e *diego*.

```
# extended LDIF

# LDAPv3
# base <ou=people,dc=example,dc=org> with scope subtree
# filter: (objectclass=*)
# requesting: uidNumber gidNumber sn 

# people, example.org
dn: ou=people,dc=example,dc=org

# diego, people, example.org
dn: cn=diego,ou=people,dc=example,dc=org
sn: B
uidNumber: 1001
gidNumber: 100

# shirley, people, example.org
dn: cn=shirley,ou=people,dc=example,dc=org
sn: A
uidNumber: 1002
gidNumber: 100

# search result
search: 2
result: 0 Success

# numResponses: 4
# numEntries: 3
```

Utilizzando le informazioni della risposta, esegui comandi all'interno del container per creare una home directory per ogni nome comune dell'utente (`cn`). Utilizza `uidNumber` e `gidNumber` per correggere la proprietà per la home directory di tale utente. I seguenti comandi di esempio eseguono questa operazione per l'utente. *shirley*

```
sudo docker container exec jupyterhub bash -c "mkdir /home/shirley"
sudo docker container exec jupyterhub bash -c "chown -R $uidNumber /home/shirley"
sudo docker container exec jupyterhub bash -c "sudo chgrp -R $gidNumber /home/shirley"
```

**Nota**  
L'autenticatore LDAP per non JupyterHub supporta la creazione di utenti locali. Per ulteriori informazioni, consulta [Nota sulla configurazione di LDAP Authenticator per la creazione di utenti locali](https://github.com/jupyterhub/ldapauthenticator#configuration-note-on-local-user-creation).   
Per creare manualmente un utente locale, utilizzare il comando seguente.  

```
sudo docker exec jupyterhub bash -c "echo 'shirley:x:$uidNumber:$gidNumber::/home/shirley:/bin/bash' >> /etc/passwd"
```

## Riavvia il contenitore JupyterHub
<a name="emr-jupyterhub-ldap-restart"></a>

Esegui i comandi seguenti per riavviare il container `jupyterhub`:

```
sudo docker stop jupyterhub
sudo docker start jupyterhub
```

# Rappresentazione dell'utente
<a name="emr-jupyterhub-user-impersonation"></a>

Un processo Spark in esecuzione all'interno di un notebook Jupyter passa attraverso più applicazioni durante la propria esecuzione su Amazon EMR. Ad esempio, il codice PySpark 3 eseguito da un utente all'interno di Jupyter viene ricevuto da Sparkmagic, che utilizza una richiesta HTTP POST per inviarlo a Livy, che quindi crea un job Spark da eseguire sul cluster utilizzando YARN.

Per impostazione predefinita, le operazioni YARN inviate in questo modo vengono eseguite come utente `livy`, indipendentemente dall'utente che ha avviato il processo. Impostando la *rappresentazione degli utenti* si può fare in modo che l'ID utente dell'utente del notebook sia anche l'utente associato al processo YARN. Anziché avere processi avviati da entrambi `shirley` e `diego` associati con l'utente `livy`, i processi avviati da ciascun utente sono associati a `shirley` e `diego` rispettivamente. In questo modo è possibile effettuare un audit dell'utilizzo di Jupyter e gestire le applicazioni all'interno della propria organizzazione.

Questa configurazione è supportata solo quando le chiamate da Sparkmagic a Livy non sono autenticate. Le applicazioni che forniscono un livello di autenticazione o di proxy tra le applicazioni Hadoop e Livy (ad esempio Apache Knox Gateway) non sono supportate. I passaggi per configurare l'impersonificazione dell'utente in questa sezione presuppongono che Livy JupyterHub e Livy siano in esecuzione sullo stesso nodo principale. Se la tua applicazione ha cluster separati, [Fase 3: crea le directory home HDFS per gli utenti](#Step3-UserImpersonation) deve essere modificato in modo che le directory HDFS vengano create nel nodo master Livy.

**Topics**
+ [Fase 1: configurazione di Livy](#Step1-UserImpersonation)
+ [Fase 2: aggiungere gli utenti](#Step2-UserImpersonation)
+ [Fase 3: crea le directory home HDFS per gli utenti](#Step3-UserImpersonation)

## Fase 1: configurazione di Livy
<a name="Step1-UserImpersonation"></a>

È possibile utilizzare le classificazioni di configurazioni `livy-conf` e `core-site` al momento della creazione di un cluster per consentire la rappresentazione dell'utente Livy come mostrato nel seguente esempio. Salva la classificazione di configurazione come JSON, quindi fai riferimento a essa al momento della creazione del cluster, oppure specifica la configurazione della classificazione inline. Per ulteriori informazioni, consulta [Configurazione delle applicazioni](emr-configure-apps.md).

```
[
  {
    "Classification": "livy-conf",
    "Properties": {
      "livy.impersonation.enabled": "true"
    }
  },
  {
    "Classification": "core-site",
    "Properties": {
      "hadoop.proxyuser.livy.groups": "*",
      "hadoop.proxyuser.livy.hosts": "*"
    }
  }
]
```

## Fase 2: aggiungere gli utenti
<a name="Step2-UserImpersonation"></a>

Aggiungi JupyterHub utenti utilizzando PAM o LDAP. Per ulteriori informazioni, consultare [Utilizzo dell'autenticazione PAM](emr-jupyterhub-pam-users.md) e [Utilizzo dell'autenticazione LDAP](emr-jupyterhub-ldap-users.md).

## Fase 3: crea le directory home HDFS per gli utenti
<a name="Step3-UserImpersonation"></a>

Ti sei connesso al nodo master per creare gli utenti. Mentre sei ancora connesso al nodo master, copia i contenuti di seguito e salvali in un file di script. Lo script crea le home directory HDFS per ogni JupyterHub utente sul nodo master. Lo script presuppone che si stia utilizzando l'ID utente amministratore predefinito,. *jovyan*

```
#!/bin/bash

CURL="curl --silent -k"
HOST=$(curl -s http://169.254.169.254/latest/meta-data/local-hostname)

admin_token() {
    local user=jovyan
    local pwd=jupyter
    local token=$($CURL https://$HOST:9443/hub/api/authorizations/token \
        -d "{\"username\":\"$user\", \"password\":\"$pwd\"}" | jq ".token")
    if [[ $token != null ]]; then
        token=$(echo $token | sed 's/"//g')
    else
        echo "Unable to get Jupyter API Token."
        exit 1
    fi
    echo $token
}

# Get Jupyter Admin token
token=$(admin_token)

# Get list of Jupyter users
users=$(curl -XGET -s -k https://$HOST:9443/hub/api/users \
 -H "Authorization: token $token" | jq '.[].name' | sed 's/"//g')

# Create HDFS home dir 
for user in ${users[@]}; 
do
 echo "Create hdfs home dir for $user"
 hadoop fs -mkdir /user/$user
 hadoop fs -chmod 777 /user/$user
done
```

# Installazione di kernel e librerie aggiuntive
<a name="emr-jupyterhub-install-kernels-libs"></a>

Quando crei un cluster con JupyterHub Amazon EMR, il kernel Python 3 predefinito per Jupyter insieme ai kernel Spark per Sparkmagic vengono installati PySpark nel contenitore Docker. Puoi installare kernel aggiuntivi. Puoi anche installare librerie e pacchetti aggiuntivi e quindi importarli per la shell appropriata.

## Installazione di un kernel
<a name="emr-jupyterhub-install-kernels"></a>

Kernel vengono installati all'interno del container Docker. Il modo più semplice per effettuare questa operazione è creare uno script bash con i comandi di installazione, salvarlo nel nodo master, quindi utilizzare il comando `sudo docker exec jupyterhub script_name` per eseguire lo script all'interno del container `jupyterhub`. Nell'esempio seguente lo script installa il kernel, quindi installa alcune librerie per tale kernel nel nodo master per consentire di importarle in seguito utilizzando il kernel in Jupyter.

```
#!/bin/bash

# Install Python 2 kernel
conda create -n py27 python=2.7 anaconda
source /opt/conda/envs/py27/bin/activate
apt-get update
apt-get install -y gcc
/opt/conda/envs/py27/bin/python -m pip install --upgrade ipykernel
/opt/conda/envs/py27/bin/python -m ipykernel install

# Install libraries for Python 2
/opt/conda/envs/py27/bin/pip install paramiko nltk scipy numpy scikit-learn pandas
```

Per installare il kernel e le librerie all'interno del container, apri una connessione del terminale al nodo master, salva lo script in `/etc/jupyter/install_kernels.sh` ed esegui il comando seguente nella riga di comando del nodo master:

```
sudo docker exec jupyterhub bash /etc/jupyter/install_kernels.sh
```

## Utilizzo di librerie e installazione di librerie aggiuntive
<a name="emr-jupyterhub-install-libs"></a>

Un set base di librerie di machine learning e data science per Python 3 è preinstallato su JupyterHub Amazon EMR. Puoi utilizzare `sudo docker exec jupyterhub bash -c "conda list" ` e `sudo docker exec jupyterhub bash -c "pip freeze"`.

Se un processo Spark richiede librerie sui nodi di lavoro, ti consigliamo di utilizzare un'operazione di bootstrap per eseguire uno script per installare le librerie durante la creazione del cluster. Le operazioni di bootstrap vengono eseguite su tutti i nodi del cluster durante il processo di creazione del cluster; ciò semplifica l'installazione. Se installi librerie su nodi principali/di lavoro dopo che un cluster è in esecuzione, l'operazione è più complessa. In questa sezione viene fornito un esempio di programma Python che mostra come installare queste librerie.

L'operazione di bootstrap e il programma Python di esempio mostrati in questa sezione utilizzano uno script bash salvato in Amazon S3 per installare le librerie su tutti i nodi.

Lo script cui si fa riferimento negli esempi seguenti utilizza `pip` per installare paramiko, nltk, scipy, scikit-learn e pandas per il kernel Python 3:

```
#!/bin/bash

sudo python3 -m pip install boto3 paramiko nltk scipy scikit-learn pandas
```

Dopo aver creato lo script, caricalo in un percorso in Amazon S3, ad esempio `s3://amzn-s3-demo-bucket/install-my-jupyter-libraries.sh`. Per ulteriori informazioni, consulta [Caricamento di oggetti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) nella *Guida per l'utente di Amazon Simple Storage Service* per utilizzare lo script nell'operazione di bootstrap o nel programma Python.

**Per specificare un'azione di bootstrap che installa le librerie su tutti i nodi quando crei un cluster utilizzando il AWS CLI**

1. Crea uno script simile all'esempio precedente e salvalo in un percorso in Amazon S3. Viene utilizzato l'esempio `s3://amzn-s3-demo-bucket/install-my-jupyter-libraries.sh`.

1. Create il cluster con JupyterHub e utilizzate l'`Path`argomento dell'`--bootstrap-actions`opzione per specificare la posizione dello script, come mostrato nell'esempio seguente:
**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 (^).

   ```
   aws emr create-cluster --name="MyJupyterHubCluster" --release-label emr-5.36.2 \
   --applications Name=JupyterHub --log-uri s3://amzn-s3-demo-bucket/MyJupyterClusterLogs \
   --use-default-roles --instance-type m5.xlarge --instance-count 2 --ec2-attributes KeyName=MyKeyPair \
   --bootstrap-actions Path=s3://amzn-s3-demo-bucket/install-my-jupyter-libraries.sh,Name=InstallJupyterLibs
   ```

**Per specificare un'operazione di bootstrap che installa librerie su tutti i nodi durante la creazione di un cluster utilizzando 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. Specificare le impostazioni per **Software and Steps (Software e fasi)** e **Hardware** come appropriato per l'applicazione.

1. Nella **General Cluster Settings (Impostazioni generali del cluster)**, espandere **Bootstrap Actions (Operazioni di bootstrap)**.

1. Per **Add bootstrap action (Aggiungi operazione di bootstrap)**, selezionare **Custom action (Operazione personalizzata)**, **Configure and add (Configura e aggiungi)**.

1. Per **Name (Nome)**, inserire un nome descrittivo. Per **Script location**, inserisci la posizione in Amazon S3 dello script (l'esempio che utilizziamo è *s3://amzn-s3-demo-bucket/ install-my-jupyter-libraries .sh*). Lasciare **Optional arguments (Argomenti opzionali)** vuoto e scegliere **Add (Aggiungi)**.

1. Specificare altre impostazioni per il cluster e scegliere **Next (Successivo)**.

1. Specificare impostazioni di sicurezza e scegliere **Create cluster (Crea cluster)**.

**Example Installazione di librerie su nodi principali di un cluster in esecuzione**  
Dopo aver installato le librerie sul nodo master dall'interno di Jupyter, puoi installare librerie su nodi principali in esecuzione in diversi modi. Nell'esempio seguente viene mostrato un programma Python scritto per l'esecuzione su un computer locale. Quando esegui il programma Python localmente, utilizza `AWS-RunShellScript` of AWS Systems Manager per eseguire lo script di esempio, mostrato in precedenza in questa sezione, che installa le librerie sui nodi principali del cluster.  

```
import argparse
import time
import boto3


def install_libraries_on_core_nodes(cluster_id, script_path, emr_client, ssm_client):
    """
    Copies and runs a shell script on the core nodes in the cluster.

    :param cluster_id: The ID of the cluster.
    :param script_path: The path to the script, typically an Amazon S3 object URL.
    :param emr_client: The Boto3 Amazon EMR client.
    :param ssm_client: The Boto3 AWS Systems Manager client.
    """
    core_nodes = emr_client.list_instances(
        ClusterId=cluster_id, InstanceGroupTypes=["CORE"]
    )["Instances"]
    core_instance_ids = [node["Ec2InstanceId"] for node in core_nodes]
    print(f"Found core instances: {core_instance_ids}.")

    commands = [
        # Copy the shell script from Amazon S3 to each node instance.
        f"aws s3 cp {script_path} /home/hadoop",
        # Run the shell script to install libraries on each node instance.
        "bash /home/hadoop/install_libraries.sh",
    ]
    for command in commands:
        print(f"Sending '{command}' to core instances...")
        command_id = ssm_client.send_command(
            InstanceIds=core_instance_ids,
            DocumentName="AWS-RunShellScript",
            Parameters={"commands": [command]},
            TimeoutSeconds=3600,
        )["Command"]["CommandId"]
        while True:
            # Verify the previous step succeeded before running the next step.
            cmd_result = ssm_client.list_commands(CommandId=command_id)["Commands"][0]
            if cmd_result["StatusDetails"] == "Success":
                print(f"Command succeeded.")
                break
            elif cmd_result["StatusDetails"] in ["Pending", "InProgress"]:
                print(f"Command status is {cmd_result['StatusDetails']}, waiting...")
                time.sleep(10)
            else:
                print(f"Command status is {cmd_result['StatusDetails']}, quitting.")
                raise RuntimeError(
                    f"Command {command} failed to run. "
                    f"Details: {cmd_result['StatusDetails']}"
                )


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("cluster_id", help="The ID of the cluster.")
    parser.add_argument("script_path", help="The path to the script in Amazon S3.")
    args = parser.parse_args()

    emr_client = boto3.client("emr")
    ssm_client = boto3.client("ssm")

    install_libraries_on_core_nodes(
        args.cluster_id, args.script_path, emr_client, ssm_client
    )


if __name__ == "__main__":
    main()
```

# JupyterHub cronologia delle versioni
<a name="JupyterHub-release-history"></a>

La tabella seguente elenca la versione JupyterHub inclusa in ogni versione di rilascio di Amazon EMR, insieme ai 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).


**JupyterHub informazioni sulla versione**  

| Etichetta di rilascio di Amazon EMR | JupyterHub versione | Componenti installati con JupyterHub | 
| --- | --- | --- | 
| emr-7.12.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.11.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.10.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.9.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.8.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.7.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.6.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.5.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.4.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.3.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.2.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.36.2 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.1.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-7.0.0 | 1.5.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.15.0 | 1.5.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.14.0 | 1.5.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.13.0 | 1.5.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.12.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.11.1 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.11.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.10.1 | 1.5.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.10.0 | 1.5.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.9.1 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.9.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.8.1 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.8.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.7.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.36.1 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.36.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.6.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.35.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.5.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.4.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.3.1 | 1.2.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.3.0 | 1.2.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.2.1 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.2.0 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.1.1 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.1.0 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.0.1 | 1.0.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-6.0.0 | 1.0.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.34.0 | 1.4.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.33.1 | 1.2.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.33.0 | 1.2.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.32.1 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.32.0 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.31.1 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.31.0 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.30.2 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.30.1 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.30.0 | 1.1.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.29.0 | 1.0.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.28.1 | 1.0.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.28.0 | 1.0.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.27.1 | 1.0.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.27.0 | 1.0.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.26.0 | 0.9.6 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.25.0 | 0.9.6 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.24.1 | 0.9.6 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.24.0 | 0.9.6 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.23.1 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.23.0 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.22.0 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.21.2 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.21.1 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.21.0 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.20.1 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.20.0 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.19.1 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.19.0 | 0.9.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.18.1 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.18.0 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.17.2 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.17.1 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.17.0 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.16.1 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.16.0 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.15.1 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.15.0 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.14.2 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.14.1 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub | 
| emr-5.14.0 | 0.8.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave, livy-server, jupyterhub |