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à.
# Utilizzo di endpoint per lo sviluppo di script
**Nota**
Gli endpoint di sviluppo sono supportati solo per le versioni AWS Glue precedenti alla 2.0. Per un ambiente interattivo in cui è possibile creare e testare script ETL, utilizza [Notebooks](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html) on Studio. AWS Glue
AWS Glue può creare un ambiente, noto come *endpoint di sviluppo*che puoi utilizzare per sviluppare e testare iterativamente gli script ETL (Extract, Transform and Load). Puoi creare, modificare ed eliminare endpoint di sviluppo utilizzando la console AWS Glue o l'API.
## Gestione dell'ambiente di sviluppo
Quando crei un endpoint di sviluppo, devi fornire i valori di configurazione per effettuare il provisioning dell'ambiente di sviluppo. Questi valori indicano a AWS Glue come configurare la rete in modo da poter accedere all'endpoint di sviluppo in tutta sicurezza e che l'endpoint possa accedere agli archivi dati.
Quindi, crea un notebook che si connette all'endpoint di sviluppo e utilizza il notebook per creare e testare lo script ETL. Quando sei soddisfatto dei risultati del processo di sviluppo, è possibile creare un processo ETL che esegue il tuo script. Con questo processo è possibile aggiungere funzioni ed eseguire il debug dello script in modo interattivo.
Segui i tutorial in questa sezione per ulteriori informazioni su come utilizzare l'endpoint di sviluppo con i notebook.
**Topics**
+ [Gestione dell'ambiente di sviluppo](#dev-endpoint-managing-dev-environment)
+ [Flusso di lavoro degli endpoint di sviluppo](dev-endpoint-workflow.md)
+ [Come funzionano gli endpoint di AWS Glue sviluppo con i notebook SageMaker](dev-endpoint-how-it-works.md)
+ [Aggiunta di un endpoint di sviluppo](add-dev-endpoint.md)
+ [Accesso all'endpoint di sviluppo](dev-endpoint-elastic-ip.md)
+ [Tutorial: configura un notebook Jupyter JupyterLab per testare ed eseguire il debug degli script ETL](dev-endpoint-tutorial-local-jupyter.md)
+ [Tutorial: utilizza un notebook SageMaker AI con il tuo endpoint di sviluppo](dev-endpoint-tutorial-sage.md)
+ [Tutorial: utilizzo di una shell (interprete di comandi) REPL con l'endpoint di sviluppo](dev-endpoint-tutorial-repl.md)
+ [Tutorial: configura un PyCharm professionista con un endpoint di sviluppo](dev-endpoint-tutorial-pycharm.md)
+ [Configurazione avanzata: condivisione degli endpoint di sviluppo tra più utenti](dev-endpoint-sharing.md)
# Flusso di lavoro degli endpoint di sviluppo
Per utilizzare un endpoint di sviluppo AWS Glue, puoi seguire questo flusso di lavoro.
1. Crea un endpoint di sviluppo utilizzando l'API. Questo endpoint viene lanciato nel tuo cloud privato virtuale (VPC, Virtual Private Cloud) con i gruppi di sicurezza da te definiti.
1. L'API è in grado di eseguire il polling dell'endpoint di sviluppo fino a quando non viene allocato ed è pronto per l'utilizzo. Quando è pronto, connettiti all'endpoint di sviluppo utilizzando uno dei seguenti metodi per creare e testare gli script AWS Glue.
+ Crea un taccuino SageMaker AI nel tuo account. Per ulteriori informazioni su come creare un notebook, consulta [Creazione di codice con notebook AWS Glue Studio](notebooks-chapter.md).
+ È possibile aprire una finestra terminale per connettersi direttamente a un endpoint di sviluppo.
+ Se hai l'edizione professionale dell'[IDE JetBrains PyCharm Python](https://www.jetbrains.com/pycharm/), collegala a un endpoint di sviluppo e usala per sviluppare in modo interattivo. Se inserisci `pydevd` istruzioni nello script, PyCharm può supportare punti di interruzione remoti.
1. Una volta terminato il debug e il test dell'endpoint di sviluppo, è possibile eliminarlo.
# Come funzionano gli endpoint di AWS Glue sviluppo con i notebook SageMaker
[Uno dei modi più comuni per accedere agli endpoint di sviluppo consiste nell'utilizzare Jupyter sui notebook.](https://jupyter.org/) SageMaker Il notebook Jupyter è un'applicazione web open source ampiamente utilizzata nella visualizzazione, nell'analisi dei dati, nel machine learning, ecc. Un AWS Glue SageMaker notebook offre un'esperienza con i notebook Jupyter con endpoint di sviluppo. AWS Glue Nel AWS Glue SageMaker notebook, l'ambiente notebook Jupyter è preconfigurato con un plug-in Jupyter open source per [SparkMagic](https://github.com/jupyter-incubator/sparkmagic)inviare i lavori Spark a un cluster Spark remoto. [Apache Livy](https://livy.apache.org) è un servizio che consente l'interazione con un cluster Spark remoto tramite una REST API. Nel AWS Glue SageMaker notebook, SparkMagic è configurato per richiamare l'API REST su un server Livy in esecuzione su un endpoint di sviluppo. AWS Glue
Il seguente flusso di testo spiega come funziona ogni componente:
*AWS Glue SageMaker notebook: (Jupyter → SparkMagic) → (rete) → endpoint di AWS Glue sviluppo: (Apache Livy → Apache Spark)*
Una volta eseguito lo script Spark scritto in ogni paragrafo su un notebook Jupyter, il codice Spark viene inviato al server Livy tramite SparkMagic, quindi un job Spark chiamato «Livy-session-n» viene eseguito sul cluster Spark. Questo processo è denominato sessione Livy. Il processo Spark verrà eseguito mentre la sessione del notebook è attiva. Il processo Spark verrà terminato quando il kernel Jupyter viene arrestato dal notebook o quando la sessione è scaduta. Viene avviato un processo Spark per ogni file notebook (.ipynb).
È possibile utilizzare un singolo endpoint di sviluppo con più istanze di notebook. AWS Glue SageMaker È possibile creare più file di notebook in ogni istanza del SageMaker notebook. Quando apri un file di notebook ed esegui i paragrafi, viene avviata una sessione Livy per ogni file del taccuino sul cluster Spark tramite. SparkMagic Ogni sessione Livy corrisponde a un singolo processo Spark.
## Comportamento predefinito per endpoint e notebook di AWS Glue sviluppo SageMaker
I processi Spark vengono eseguiti in base alla [configurazione di Spark](https://spark.apache.org/docs/2.4.3/configuration.html). Esistono diversi modi per impostare la configurazione di Spark (ad esempio, la configurazione del cluster Spark, la configurazione SparkMagic di Spark, ecc.).
Per impostazione predefinita, Spark alloca le risorse del cluster a una sessione Livy in base alla configurazione del cluster Spark. Nell'endpoint di sviluppo AWS Glue, la configurazione del cluster dipende dal tipo di worker. Ecco una tabella che spiega le configurazioni comuni per tipo di worker.
****
| | Standard | G.1X | G.2X |
| --- | --- | --- | --- |
| spark.driver.memory | 5G | 10G | 20G |
| spark.executor.memory | 5G | 10G | 20G |
| spark.executor.cores | 4 | 8 | 16 |
| spark.dynamicAllocation.enabled | TRUE | TRUE | TRUE |
Il numero massimo di executor Spark viene calcolato automaticamente in base alla combinazione di DPU (o `NumberOfWorkers`) e il tipo di dipendente.
****
| | Standard | G.1X | G.2X |
| --- | --- | --- | --- |
| Il numero massimo di executor Spark | (DPU - 1) \$1 2 - 1 | (NumberOfWorkers - 1) | (NumberOfWorkers - 1) |
Ad esempio, se l'endpoint di sviluppo ha 10 worker e il tipo di worker è ` G.1X`, allora si avranno 9 executor Spark e l'intero cluster avrà 90G di memoria dell'executor, poiché ogni executor avrà 10G di memoria.
Indipendentemente dal tipo di worker specificato, verrà attivata l'allocazione dinamica delle risorse Spark. Se un set di dati è abbastanza grande, Spark potrebbe allocare tutti gli executor a una singola sessione Livy poiché `spark.dynamicAllocation.maxExecutors` non è configurata per impostazione predefinita. Ciò significa che altre sessioni Livy sullo stesso endpoint di sviluppo attenderanno per l'avvio di nuovi executor. Se il set di dati è piccolo, Spark sarà in grado di allocare gli esecutori a più sessioni Livy contemporaneamente.
**Nota**
Per ulteriori informazioni sull'allocazione delle risorse in diversi casi d'uso e su come impostare una configurazione che modifichi il funzionamento, consulta [Configurazione avanzata: condivisione degli endpoint di sviluppo tra più utenti](dev-endpoint-sharing.md).
# Aggiunta di un endpoint di sviluppo
Utilizza gli endpoint di sviluppo per lo sviluppo iterativo e per il test di script di estrazione, trasformazione e caricamento (ETL) in AWS Glue. È possibile utilizzare gli endpoint di sviluppo solo tramite la AWS Command Line Interface.
1. In una finestra a riga di comando, immetti un comando simile al seguente.
```
aws glue create-dev-endpoint --endpoint-name "endpoint1" --role-arn "arn:aws:iam::account-id:role/role-name" --number-of-nodes "3" --glue-version "1.0" --arguments '{"GLUE_PYTHON_VERSION": "3"}' --region "region-name"
```
Questo comando specifica AWS Glue versione 1.0. Poiché questa versione supporta sia Python 2 sia Python 3, puoi utilizzare il parametro `arguments` per indicare la versione di Python desiderata. Se il parametro `glue-version` viene omesso, viene utilizzato AWS Glue versione 0.9. Per ulteriori informazioni sulle versioni di AWS Glue, consulta [Glue version job property](add-job.md#glue-version-table).
Per informazioni sui parametri aggiuntivi della riga di comando, vedere [create-dev-endpoint](https://docs.aws.amazon.com/cli/latest/reference/glue/create-dev-endpoint.html)nel *AWS CLI Command Reference.*
1. (Facoltativo) Immetti il comando seguente per controllare lo stato dell'endpoint di sviluppo. Quando lo stato cambia in `READY`, l'endpoint di sviluppo è pronto per l'uso.
```
aws glue get-dev-endpoint --endpoint-name "endpoint1"
```
# Accesso all'endpoint di sviluppo
Quando crei un endpoint di sviluppo in un cloud privato virtuale (VPC, Virtual Private Cloud), AWS Glue restituisce solo un indirizzo IP privato. Il campo dell'indirizzo IP pubblico non è compilato. Quando crei un endpoint non di sviluppo non VPC, AWS Glue restituisce solo un indirizzo IP pubblico.
Se l'endpoint di sviluppo dispone di un **Public address (Indirizzo pubblico)**, conferma che sia raggiungibile con la chiave privata SSH per l'endpoint di sviluppo, come nell'esempio seguente.
```
ssh -i dev-endpoint-private-key.pem glue@public-address
```
Supponi che l'endpoint di sviluppo disponga di un **Private address (Indirizzo privato)**, che la sottorete VPC sia instradabile dalla rete Internet pubblica e che i relativi gruppi di sicurezza consentano l'accesso in entrata dal client. In questo caso, segui questa procedura per collegare un *indirizzo IP elastico* a un endpoint di sviluppo per consentire l'accesso da Internet.
**Nota**
Se desideri utilizzare indirizzi IP elastici, la sottorete utilizzata richiede un gateway Internet associato tramite la tabella di routing.
**Per accedere a un endpoint di sviluppo collegando un indirizzo IP elastico**
1. Apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel pannello di navigazione, scegli **Dev endpoints (Endpoint di sviluppo)** e passa alla pagina dei dettagli dell'endpoint di sviluppo. Registra il **Private address** (Indirizzo privato) da utilizzare nella fase successiva.
1. Apri la EC2 console Amazon all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel pannello di navigazione, in **Network & Security (Rete e sicurezza)**, scegli **Network Interfaces (Interfacce di rete)**.
1. Cerca il **DNS privato (IPv4)** che corrisponde all'**indirizzo privato** nella pagina dei dettagli dell'endpoint di sviluppo della AWS Glue console.
Potrebbe essere necessario modificare le colonne visualizzate sulla EC2 console Amazon. Prendi nota del **Network interface ID (ID interfaccia di rete, ENI)** per questo indirizzo (ad esempio, `eni-12345678`).
1. Sulla EC2 console Amazon, in **Rete e sicurezza**, scegli **Elastic IPs**.
1. Scegli **Allocate new address (Alloca nuovo indirizzo)**, quindi seleziona **Allocate (Alloca)** per allocare un nuovo indirizzo IP elastico.
1. Nella IPs pagina **Elastic**, scegli l'**IP elastico** appena allocato. Quindi scegli **Actions** (Operazioni), **Associate address** (Associa indirizzo).
1. Nella pagina **Associate address (Associa indirizzo)**, procedi come segue:
+ Per il **Resource type** (Tipo di risorsa), scegli **Network interface** (Interfaccia di rete).
+ Nella casella **Network interface (Interfaccia di rete)** , immetti il **Network interface ID (ID interfaccia di rete, ENI)** dell'indirizzo privato.
+ Selezionare **Associate (Associa)**.
1. Conferma che l'indirizzo IP elastico appena associato sia raggiungibile con la chiave privata SSH associata all'endpoint di sviluppo, come nell'esempio seguente.
```
ssh -i dev-endpoint-private-key.pem glue@elastic-ip
```
Per informazioni sull'utilizzo di un bastion host per ottenere l'accesso SSH all'indirizzo privato dell'endpoint di sviluppo, consulta il post AWS Security Blog Securely [Connect to Linux Instances Running in a Private](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/) Amazon VPC.
# Tutorial: configura un notebook Jupyter JupyterLab per testare ed eseguire il debug degli script ETL
In questo tutorial, colleghi un notebook Jupyter in JupyterLab esecuzione sul tuo computer locale a un endpoint di sviluppo. Questa operazione serve per poter eseguire, eseguire il debug e testare in modo interattivo l'estrazione, la trasformazione e il caricamento di script (ETL) AWS Glue prima di distribuirli. Questo tutorial usa l'inoltro della porta Secure Shell (SSH) per connettere il computer locale a un endpoint di sviluppo AWS Glue. Per ulteriori informazioni, consulta [Inoltro della porta](https://en.wikipedia.org/wiki/Port_forwarding) in Wikipedia.
## Fase 1: Installazione e Sparkmagic JupyterLab
È possibile eseguire l'installazione JupyterLab utilizzando `conda` o`pip`. `conda`è un sistema di gestione dei pacchetti open source e un sistema di gestione dell'ambiente che funziona su Windows, macOS e Linux. `pip`è l'installatore di pacchetti per Python.
Se esegui l'installazione su macOS, devi avere Xcode installato prima di poter installare Sparkmagic.
1. Install JupyterLab, Sparkmagic e le relative estensioni.
```
$ conda install -c conda-forge jupyterlab
$ pip install sparkmagic
$ jupyter nbextension enable --py --sys-prefix widgetsnbextension
$ jupyter labextension install @jupyter-widgets/jupyterlab-manager
```
1. Controlla la directory `sparkmagic` da `Location`.
```
$ pip show sparkmagic | grep Location
Location: /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages
```
1. Cambia la tua directory con quella restituita per`Location`, e installa i kernel per Scala e. PySpark
```
$ cd /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages
$ jupyter-kernelspec install sparkmagic/kernels/sparkkernel
$ jupyter-kernelspec install sparkmagic/kernels/pysparkkernel
```
1. Scarica un esempio di file `config`.
```
$ curl -o ~/.sparkmagic/config.json https://raw.githubusercontent.com/jupyter-incubator/sparkmagic/master/sparkmagic/example_config.json
```
In questo file di configurazione, è possibile configurare parametri relativi a Spark come `driverMemory` e `executorCores`.
## Fase 2: Inizia JupyterLab
All'avvio JupyterLab, il browser Web predefinito viene aperto automaticamente e `http://localhost:8888/lab/workspaces/{workspace_name}` viene visualizzato l'URL.
```
$ jupyter lab
```
## Fase 3: avviare l'inoltro alla porta SSH per la connessione all'endpoint di sviluppo
Usa quindi l'inoltro porta locale SSH per inoltrare una porta locale (qui, `8998`) alla destinazione remota definita da AWS Glue (`169.254.76.1:8998`).
1. Apri una finestra separata del terminale che ti consente di accedere a SSH. Su Microsoft Windows, puoi utilizzare la shell BASH fornita da [Git for Windows](https://git-scm.com/downloads) o installare [Cygwin](https://www.cygwin.com/).
1. Esegui il comando SSH seguente, modificato come segue:
+ Sostituisci `private-key-file-path` con un percorso al file `.pem` contenente la chiave privata corrispondente alla chiave pubblica utilizzata per creare l'endpoint di sviluppo.
+ Se stai inoltrando una porta diversa da `8998`, sostituisci `8998` con il numero di porta che stai effettivamente usando in locale. L'indirizzo `169.254.76.1:8998` è la porta remota e non è modificata da te.
+ Sostituisci `dev-endpoint-public-dns` con l'indirizzo DNS pubblico del tuo endpoint di sviluppo. Per trovare questo indirizzo, passa all'endpoint di sviluppo nella console AWS Glue, scegli il nome e copia il valore di **Public address (Indirizzo pubblico)** elencato nella pagina **Endpoint details (Dettagli endpoint)**.
```
ssh -i private-key-file-path -NTL 8998:169.254.76.1:8998 glue@dev-endpoint-public-dns
```
È probabile che vedrai un messaggio di avviso, come il seguente:
```
The authenticity of host 'ec2-xx-xxx-xxx-xx.us-west-2.compute.amazonaws.com (xx.xxx.xxx.xx)'
can't be established. ECDSA key fingerprint is SHA256:4e97875Brt+1wKzRko+JflSnp21X7aTP3BcFnHYLEts.
Are you sure you want to continue connecting (yes/no)?
```
Entra **yes** e lascia aperta la finestra del terminale durante l'uso JupyterLab.
1. Verifica che l'inoltro porta SSH funzioni correttamente con l'endpoint di sviluppo.
```
$ curl localhost:8998/sessions
{"from":0,"total":0,"sessions":[]}
```
## Fase 4: eseguire un semplice frammento di script in un paragrafo del notebook
Ora il notebook in JupyterLab dovrebbe funzionare con il tuo endpoint di sviluppo. Digita il frammento di script seguente nel notebook ed eseguilo.
1. Verifica che Spark sia in esecuzione correttamente. Il comando seguente indica a Spark di calcolare `1` e quindi stampare il valore.
```
spark.sql("select 1").show()
```
1. Verifica se AWS Glue Data Catalog l'integrazione funziona. Il comando seguente elenca le tabelle nel catalogo dati.
```
spark.sql("show tables").show()
```
1. Verifica che un frammento di script semplice che utilizza le librerie AWS Glue funzioni.
Lo script seguente utilizza i metadati della tabella `persons_json` in AWS Glue Data Catalog per creare un`DynamicFrame`dai dati di esempio. Quindi, verranno stampati il conteggio item e lo schema di questi dati.
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
# Create a Glue context
glueContext = GlueContext(SparkContext.getOrCreate())
# Create a DynamicFrame using the 'persons_json' table
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
# Print out information about *this* data
print("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
L'output dello script è il seguente.
```
Count: 1961
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- note: string
| | |-- name: string
| | |-- lang: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string
```
## Risoluzione dei problemi
+ Durante l'installazione di JupyterLab, se il computer è protetto da un proxy o firewall aziendale, è possibile che si verifichino errori HTTP e SSL dovuti ai profili di sicurezza personalizzati gestiti dai reparti IT aziendali.
Di seguito è riportato un esempio di errore tipico che si verifica quando `conda` non è in grado di connettersi ai propri repository:
```
CondaHTTPError: HTTP 000 CONNECTION FAILED for url
```
Ciò potrebbe accadere perché la tua azienda può bloccare le connessioni a repository ampiamente utilizzati in Python JavaScript e nelle community. Per ulteriori informazioni, consulta [Problemi di installazione](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html#installation-problems) sul JupyterLab sito Web.
+ Se si verifica un errore di *connessione rifiutata* quando provi a connetterti all'endpoint di sviluppo, potresti utilizzare un endpoint di sviluppo obsoleto. Prova a creare un nuovo endpoint di sviluppo e a riconnetterti.
# Tutorial: utilizza un notebook SageMaker AI con il tuo endpoint di sviluppo
NelAWS Glue, puoi creare un endpoint di sviluppo e quindi creare un notebook SageMaker AI per aiutarti a sviluppare i tuoi script ETL e di machine learning. Un notebook SageMaker AI è un'istanza di calcolo di machine learning completamente gestita che esegue l'applicazione Jupyter Notebook.
1. Nella console AWS Glue seleziona **Dev endpoints (Endpoint di sviluppo)** per passare all'elenco degli endpoint di sviluppo.
1. **Seleziona la casella di controllo accanto al nome di un endpoint di sviluppo che desideri utilizzare e, nel menu **Azione**, scegli Crea notebook. SageMaker**
1. Compilare la pagina **Create and configure a notebook (Crea e configura un notebook)** come segue:
1. Immettere il nome di un notebook.
1. In **Attach to development endpoint (Collega a endpoint di sviluppo)**, verificare l'endpoint di sviluppo.
1. Crea o scegli un ruolo AWS Identity and Access Management (IAM).
Si consiglia di creare un ruolo. Se si utilizza un ruolo esistente, assicurarsi di avere le autorizzazioni necessarie. Per ulteriori informazioni, consulta [Fase 6: Creare una policy IAM per i notebook SageMaker AI](create-sagemaker-notebook-policy.md).
1. (Facoltativo) Scegliere un VPC, una sottorete e uno o più gruppi di sicurezza.
1. (Facoltativo) Scegli una chiave di AWS Key Management Service crittografia.
1. (Facoltativo) Aggiungere i tag per l'istanza del notebook.
1. Seleziona **Crea notebook**. Sulla pagina **Notebooks (Notebook)**, scegli l'icona di aggiornamento in alto a destra e continua fino a quando la finestra **Status (Stato)** non mostra `Ready`.
1. Selezionare la casella di controllo accanto al nuovo nome del notebook, quindi scegliere **Open notebook (Apri notebook)**.
1. Crea un nuovo taccuino: nella pagina di **jupyter**, scegli **Nuovo**, quindi scegli **Sparkmagic** (). PySpark
La schermata dovrebbe essere simile alla seguente:
![\[La pagina jupyter ha una barra dei menu, una barra degli strumenti e un ampio campo di testo in cui è possibile inserire le istruzioni.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/sagemaker-notebook.png)
1. (Facoltativo) Nella parte superiore della pagina, scegliere **Untitled (Senza titolo)** e assegnare un nome al notebook.
1. Per avviare un'applicazione Spark, immettere il seguente comando nel notebook e quindi nella barra degli strumenti scegliere **Run (Esegui)**.
```
spark
```
Dopo una breve attesa, viene visualizzata la seguente risposta:
![\[La risposta del sistema mostra lo stato dell'applicazione Spark e restituisce il seguente messaggio: disponibile come 'spark'. SparkSession\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/spark-command-response.png)
1. Creare un frame dinamico ed eseguirvi una query: copiare, incollare ed eseguire il codice seguente, che restituisce il conteggio e lo schema della tabella `persons_json`.
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Tutorial: utilizzo di una shell (interprete di comandi) REPL con l'endpoint di sviluppo
InAWS Glue, puoi creare un endpoint di sviluppo e quindi richiamare una shell REPL (Read—Evaluate—Print Loop) per eseguire il PySpark codice in modo incrementale in modo da poter eseguire il debug interattivo degli script ETL prima di distribuirli.
Per utilizzare una REPL su un endpoint di sviluppo, è necessario disporre dell'autorizzazione SSH all'endpoint.
1. Sul tuo computer locale, apri una finestra terminale che possa eseguire comandi SSH e incolla il comando SSH modificato. Esegui il comando .
Se hai accettato AWS Glue versione 1.0 con Python 3 per l'endpoint di sviluppo, l'aspetto dell'output sarà simile al seguente:
```
Python 3.6.8 (default, Aug 2 2019, 17:42:44)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux
Type "help", "copyright", "credits" or "license" for more information.
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/usr/share/aws/glue/etl/jars/glue-assembly.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/usr/lib/spark/jars/slf4j-log4j12-1.7.16.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
2019-09-23 22:12:23,071 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Neither spark.yarn.jars nor spark.yarn.archive is set, falling back to uploading libraries under SPARK_HOME.
2019-09-23 22:12:26,562 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same name resource file:/usr/lib/spark/python/lib/pyspark.zip added multiple times to distributed cache
2019-09-23 22:12:26,580 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/etl/python/PyGlue.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/lib/spark/python/lib/py4j-src.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/libs/pyspark.zip added multiple times to distributed cache.
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/__ / .__/\_,_/_/ /_/\_\ version 2.4.3
/_/
Using Python version 3.6.8 (default, Aug 2 2019 17:42:44)
SparkSession available as 'spark'.
>>>
```
1. Verifica che la REPL shell funzioni correttamente digitando l'istruzione `print(spark.version)`. Finché visualizza la versione Spark, la REPL è pronta per l'uso.
1. Ora puoi provare a eseguire il seguente script semplice, riga per riga, nella shell:
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Tutorial: configura un PyCharm professionista con un endpoint di sviluppo
Questo tutorial mostra come connettere l'IDE [PyCharm Professional](https://www.jetbrains.com/pycharm/) Python in esecuzione sul computer locale a un endpoint di sviluppo in modo da poter eseguire, eseguire il debug e testare in modo interattivo gli script AWS Glue ETL (estrazione, trasferimento e caricamento) prima di distribuirli. Le istruzioni e le schermate del tutorial si basano sulla versione Professional 2019.3. PyCharm
Per connetterti a un endpoint di sviluppo in modo interattivo, devi avere installato Professional. PyCharm Non puoi farlo usando l'edizione gratuita.
**Nota**
Il tutorial utilizza Amazon S3 come origine dati. Se invece desideri utilizzare un'origine dati JDBC, devi eseguire l'endpoint di sviluppo in un cloud privato virtuale (VPC). Per connetterti con SSH a un endpoint di sviluppo in un VPC, devi creare un tunnel SSH. Questo tutorial non include le istruzioni per la creazione di un tunnel SSH. Per informazioni sull'uso di SSH per connettersi a un endpoint di sviluppo in un VPC, consulta Securely [Connect to Linux Instances Running in un Amazon VPC privato](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/) nel blog sulla sicurezza. AWS
**Topics**
+ [Connessione di un professionista a un endpoint di sviluppo PyCharm](#dev-endpoint-tutorial-pycharm-connect)
+ [Distribuzione dello script nell'endpoint di sviluppo](#dev-endpoint-tutorial-pycharm-deploy)
+ [Configurazione di un interprete remoto](#dev-endpoint-tutorial-pycharm-interpreter)
+ [Esecuzione dello script sull'endpoint di sviluppo](#dev-endpoint-tutorial-pycharm-debug-run)
## Connessione di un professionista a un endpoint di sviluppo PyCharm
1. Crea un nuovo progetto Pure-Python in named. PyCharm `legislators`
1. Crea un file denominato `get_person_schema.py` nel progetto con il seguente contenuto:
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
def main():
# Create a Glue context
glueContext = GlueContext(SparkContext.getOrCreate())
# Create a DynamicFrame using the 'persons_json' table
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
# Print out information about this data
print("Count: ", persons_DyF.count())
persons_DyF.printSchema()
if __name__ == "__main__":
main()
```
1. Esegui una delle seguenti operazioni:
+ Per AWS Glue versione 0.9, scarica il file della libreria Python AWS Glue, `PyGlue.zip`, da `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl/python/PyGlue.zip` a un percorso appropriato nel computer locale.
+ Per AWS Glue versione 1.0, scarica il file della libreria Python AWS Glue, `PyGlue.zip`, da `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl-1.0/python/PyGlue.zip` a un percorso appropriato nel computer locale.
1. Aggiungi `PyGlue.zip` come radice di contenuto per il tuo progetto in: PyCharm
+ In PyCharm, scegliete **File**, **Impostazioni** per aprire la finestra di dialogo **Impostazioni**. Puoi anche premere `Ctrl+Alt+S`.
+ Espandi il progetto `legislators` e scegli **Project Structure** (Struttura del progetto). Quindi nel riquadro di destra, scegli **\$1 Add Content Root** (\$1 Aggiungi Content Root).
+ Seleziona il percorso in cui hai salvato `PyGlue.zip`, selezionalo, quindi scegli **Apply** (Applica).
La schermata **Settings** (Impostazioni) deve avere un aspetto simile al seguente:
![\[La schermata PyCharm Impostazioni con PyGlue .zip aggiunto come radice del contenuto.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/PyCharm_AddContentRoot.png)
Lascia aperta la finestra di dialogo **Settings** (Impostazioni) dopo aver scelto **Apply** (Applica).
1. Configura le opzioni di distribuzione per caricare lo script locale sull'endpoint di sviluppo utilizzando SFTP (questa funzionalità è disponibile solo in PyCharm Professional):
+ Nella finestra di dialogo **Settings** (Impostazioni), espandi la sezione **Build, Execution, Deployment** (Creazione, esecuzione e distribuzione). Scegli la sottosezione **Deployment** (Distribuzione).
+ Scegli l'icona **\$1** in alto nel riquadro centrale per aggiungere un nuovo server. Imposta il **Type (Tipo)** su `SFTP` e assegna un nome.
+ Imposta **SFTP host (Host SFTP)** sull'**indirizzo pubblico** dell'endpoint di sviluppo, come indicato nella pagina dei dettagli. Scegli il nome dell'endpoint di sviluppo nella console AWS Glue per visualizzare la pagina dei dettagli. Per un endpoint di sviluppo in esecuzione in un VPC, imposta l'**host SFTP** sull'indirizzo host e la porta locale del tunnel SSH sull'endpoint di sviluppo.
+ Imposta lo **User name** (Nome utente) su `glue`.
+ Imposta l'**Auth type** (Tipo di autenticazione) per la **Key pair (OpenSSH or Putty)** (Coppia di chiavi, OpenSSH o Putty). Imposta il **Private key file** (File della chiave privata) cercando il percorso in cui si trova il file della chiave privata dell'endpoint di sviluppo. Nota che supporta PyCharm solo i tipi di chiave OpenSSH DSA, RSA ed ECDSA e non accetta chiavi nel formato privato di Putty. È possibile utilizzare una up-to-date versione di per generare un tipo di coppia di chiavi `ssh-keygen` che accetti, utilizzando una sintassi come la seguente: PyCharm
```
ssh-keygen -t rsa -f -C ""
```
+ Scegli **Test connection (Test connessione)** e consenti il test della connessione. Se la connessione viene stabilita, scegli **Apply** (Applica).
La schermata **Settings** (Impostazioni) ora deve avere un aspetto simile al seguente:
![\[La schermata PyCharm Impostazioni con un server SFTP definito.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/PyCharm_SFTP.png)
Lascia nuovamente aperta la finestra di dialogo **Settings** (Impostazioni) dopo aver scelto **Apply** (Applica).
1. Imposta la directory locale su una directory remota per la distribuzione:
+ Nel riquadro a destra della pagina **Deployment** (Distribuzione), scegli la scheda centrale nella parte superiore, contrassegnata dall'etichetta **Mappings** (Mappe).
+ Nella colonna **Deployment Path** (Percorso di distribuzione), immetti un percorso sotto `/home/glue/scripts/` per la distribuzione del percorso del progetto. Ad esempio: `/home/glue/scripts/legislators`.
+ Scegli **Applica**.
La schermata **Settings** (Impostazioni) ora deve avere un aspetto simile al seguente:
![\[La schermata PyCharm Impostazioni dopo una mappatura della distribuzione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/PyCharm_Mapping.png)
Scegli **OK** per chiudere la finestra di dialogo **Settings (Impostazioni)**.
## Distribuzione dello script nell'endpoint di sviluppo
1. Scegli **Tools (Strumenti)**, **Deployment (Distribuzione)**, quindi scegli il nome con cui hai configurato l'endpoint di sviluppo, come illustrato nell'immagine seguente:
![\[Voce di menu per la distribuzione dello script.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/PyCharm_Deploy.png)
Dopo che lo script è stato distribuito, la parte inferiore della schermata deve avere un aspetto simile al seguente:
![\[La parte inferiore dello PyCharm schermo dopo una distribuzione riuscita.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/PyCharm_Deployed.png)
1. Nella barra dei menu scegli **Tools (Strumenti)**, **Deployment (Distribuzione)**, **Automatic Upload (always) (Caricamento automatico (sempre))**. Accertati che venga visualizzato un segno di spunta accanto a **Automatic Upload (always) (Caricamento automatico (sempre))**.
Quando questa opzione è abilitata, carica PyCharm automaticamente i file modificati sull'endpoint di sviluppo.
## Configurazione di un interprete remoto
Configura PyCharm per utilizzare l'interprete Python sull'endpoint di sviluppo.
1. Nel menu **File**, scegli **Settings (Impostazioni)**.
1. Espandi i **legislators (legislatori)** del progetto e scegli **Project Interpreter (Interprete di progetto)**.
1. Scegli l'icona a forma di ingranaggio accanto all'elenco **Project Interpreter (Interprete di progetto)** quindi scegli **Add (Aggiungi)**.
1. Nella finestra di dialogo **Add Python Interpreter (Aggiungi interprete Python)** nel riquadro di sinistra, scegli **SSH Interpreter (Interprete SSH)**.
1. Scegli **Existing server configuration (Configurazione server esistente)** e nell'elenco **Deployment configuration (Configurazione distribuzione)** scegli la configurazione.
La schermata ora deve avere un aspetto simile all'immagine seguente.
![\[Nel riquadro di sinistra è selezionato l'interprete SSH e nel riquadro di destra è selezionato il pulsante di opzione Existing server configuration (Configurazione server esistente). Il campo Deployment configuration (Configurazione distribuzione) contiene il nome della configurazione e il messaggio indicante che l'SDK remoto viene salvato nelle impostazioni dell'IDE e quindi è necessario salvarvi anche il server di distribuzione. Quindi vengono elencate le preferenze. Di seguito sono riportate le opzioni disponibili: "Create copy of this deployment server in IDE settings (Crea copia del server di distribuzione nelle impostazioni IDE)" e "Move this server to IDE settings (Sposta il server nelle impostazioni IDE".\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/PyCharm_Interpreter1.png)
1. Scegli **"Move this server to IDE settings (Sposta il server nelle impostazioni IDE"**, quindi seleziona **Next (Successivo)**.
1. Nel campo **Interpreter (Interprete)** cambia il percorso in ` /usr/bin/gluepython` se stai usando Python 2 o in `/usr/bin/gluepython3` se stai usando Python 3. Quindi scegli **Finish (Fine)**.
## Esecuzione dello script sull'endpoint di sviluppo
Per eseguire lo script:
+ Nel riquadro sinistro, fai clic con il pulsante destro del mouse sul nome del file e scegli **Esegui** ''. **
Dopo una serie di messaggi, l'output finale mostra il conteggio e lo schema.
```
Count: 1961
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- lang: string
| | |-- note: string
| | |-- name: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string
Process finished with exit code 0
```
Ora hai effettuato la configurazione per eseguire il debug dello script in remoto sul tuo endpoint di sviluppo.
# Configurazione avanzata: condivisione degli endpoint di sviluppo tra più utenti
Questa sezione spiega come sfruttare gli endpoint di sviluppo con SageMaker notebook nei casi d'uso tipici per condividere gli endpoint di sviluppo tra più utenti.
## Configurazione tenancy singola
Nei casi d'uso a tenant singolo, per semplificare l'esperienza degli sviluppatori ed evitare conflitti per le risorse, è consigliabile che ogni sviluppatore utilizzi il proprio endpoint di sviluppo per il progetto su cui sta lavorando. Ciò semplifica anche le decisioni relative al tipo di worker e al conteggio DPU, lasciandole a discrezione dello sviluppatore e del progetto su cui sta lavorando.
Non dovrai occuparti dell'allocazione delle risorse a meno che non vengano eseguiti simultaneamente più file notebook. Se esegui il codice in più file notebook contemporaneamente, verranno avviate contemporaneamente più sessioni Livy. Per separare le configurazioni del cluster Spark al fine di eseguire più sessioni Livy contemporaneamente, puoi seguire i passaggi introdotti nei casi d'uso multi-tenant.
Ad esempio, se l'endpoint di sviluppo ha 10 worker e il tipo di worker è ` G.1X`, allora si avranno 9 executor Spark e l'intero cluster avrà 90G di memoria dell'executor, poiché ogni executor avrà 10G di memoria.
Indipendentemente dal tipo di worker specificato, verrà attivata l'allocazione dinamica delle risorse Spark. Se un set di dati è abbastanza grande, Spark potrebbe allocare tutti gli executor a una singola sessione Livy poiché `spark.dynamicAllocation.maxExecutors` non è configurata per impostazione predefinita. Ciò significa che altre sessioni Livy sullo stesso endpoint di sviluppo attenderanno per l'avvio di nuovi executor. Se il set di dati è piccolo, Spark sarà in grado di allocare gli esecutori a più sessioni Livy contemporaneamente.
**Nota**
Per ulteriori informazioni sull'allocazione delle risorse in diversi casi d'uso e su come impostare una configurazione che modifichi il funzionamento, consulta [Configurazione avanzata: condivisione degli endpoint di sviluppo tra più utenti](#dev-endpoint-sharing).
### Configurazione tenancy multipla
**Nota**
Tieni presente che gli endpoint di sviluppo hanno lo scopo di emulare l'ambiente ETL AWS Glue come ambiente a tenant singolo. Sebbene l'utilizzo di multi-tenant sia possibile, si tratta di un caso d'uso avanzato e alla maggior parte degli utenti si consiglia di mantenere un modello di tenancy singolo per ogni endpoint di sviluppo.
Nei casi d'uso multi-tenant, potresti doverti occupare dell'allocazione delle risorse. Il fattore chiave è il numero di utenti che utilizzano contemporaneamente un notebook Jupyter. Se il tuo team lavora in un flusso di lavoro follow-the-sun "" e c'è un solo utente Jupyter per fuso orario, il numero di utenti simultanei è solo uno, quindi non dovrai preoccuparti dell'allocazione delle risorse. Tuttavia, se il notebook è condiviso tra più utenti e ogni utente invia il codice ad hoc, sarà necessario considerare i seguenti punti.
Per partizionare le risorse del cluster Spark tra più utenti, puoi utilizzare le configurazioni. SparkMagic Esistono due modi diversi per configurare. SparkMagic
#### (A) Utilizzo della direttiva %%configure -f
Se vuoi modificare la configurazione per sessione Livy dal notebook, puoi eseguire la direttiva `%%configure -f` sul paragrafo di notebook.
Ad esempio, se vuoi eseguire l'applicazione Spark su 5 executor, puoi eseguire il comando seguente nel paragrafo di notebook.
```
%%configure -f
{"numExecutors":5}
```
Vedrai quindi solo 5 executor in esecuzione per il processo sull'interfaccia utente di Spark.
Si consiglia di limitare il numero massimo di executor per l'allocazione dinamica delle risorse.
```
%%configure -f
{"conf":{"spark.dynamicAllocation.maxExecutors":"5"}}
```
#### (B) Modifica il SparkMagic file di configurazione
SparkMagic funziona in base all'API [Livy.](https://livy.incubator.apache.org/docs/latest/rest-api.html) SparkMagic crea sessioni Livy con configurazioni come`driverMemory`,,,` driverCores`,`executorMemory`, `executorCores`` numExecutors`, ecc. `conf` Questi sono i fattori chiave che determinano la quantità di risorse consumate dall'intero cluster Spark. SparkMagic consente di fornire un file di configurazione per specificare i parametri che vengono inviati a Livy. Puoi vedere un file di configurazione di esempio in questo [repository Github](https://github.com/jupyter-incubator/sparkmagic/blob/master/sparkmagic/example_config.json).
Se vuoi modificare la configurazione di tutte le sessioni Livy da un notebook, puoi modificare `/home/ec2-user/.sparkmagic/config.json` per aggiungere `session_config`.
Per modificare il file di configurazione su un'istanza di SageMaker notebook, puoi seguire questi passaggi.
1. Apri un SageMaker taccuino.
1. Apri il kernel del terminale.
1. Esegui i comandi seguenti:
```
sh-4.2$ cd .sparkmagic
sh-4.2$ ls
config.json logs
sh-4.2$ sudo vim config.json
```
Ad esempio, puoi aggiungere queste righe a ` /home/ec2-user/.sparkmagic/config.json` e riavviare il kernel Jupyter dal notebook.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
### Linee guida e best practice
Per evitare questo tipo di conflitto di risorse, puoi utilizzare alcuni approcci di base come:
+ Avere un cluster Spark più grande aumentando il `NumberOfWorkers` (dimensionamento orizzontale) e aggiornando il `workerType` (dimensionamento verticale)
+ Allocare di meno risorse per utente (meno risorse per sessione Livy)
Il tuo approccio dipenderà dal caso d'uso. Se disponi di un endpoint di sviluppo più grande e non vi è una quantità enorme di dati, la possibilità di un conflitto di risorse diminuirà significativamente perché Spark può allocare risorse in base a una strategia di allocazione dinamica.
Come descritto sopra, il numero massimo di executor Spark viene calcolato automaticamente in base alla combinazione di DPU (o `NumberOfWorkers`) e il tipo di worker. Ogni applicazione Spark avvia un driver e più executor. Per il calcolo è necessario il ` NumberOfWorkers` = `NumberOfExecutors + 1`. La matrice seguente illustra la capacità necessaria nell'endpoint di sviluppo in base al numero di utenti simultanei.
****
| Numero di utenti simultanei del notebook | Numero di executor Spark che vuoi allocare per utente | Totale NumberOfWorkers per il tuo endpoint di sviluppo |
| --- | --- | --- |
| 3 | 5 | 18 |
| 10 | 5 | 60 |
| 50 | 5 | 300 |
Se vuoi allocare meno risorse per utente, ` spark.dynamicAllocation.maxExecutors` (o `numExecutors`) è il parametro più semplice da configurare come parametro di sessione Livy. Se imposti la configurazione seguente`/home/ec2-user/.sparkmagic/config.json`, SparkMagic assegnerà un massimo di 5 esecutori per sessione Livy. Questo aiuterà a separare le risorse per sessione Livy.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
Supponiamo che ci sia un endpoint di sviluppo con 18 worker (G.1X) e 3 utenti del notebook contemporaneamente. Se la configurazione della sessione ha ` spark.dynamicAllocation.maxExecutors=5`, ogni utente può utilizzare 1 driver e 5 executor. Anche eseguendo più paragrafi di notebook simultaneamente, non si verificheranno conflitti di risorse.
#### Pro e contro
Con questa configurazione di sessione `"spark.dynamicAllocation.maxExecutors":"5"`, potrai evitare errori di conflitto di risorse e non sarà necessario attendere l'allocazione delle risorse in caso di accessi utente simultanei. Tuttavia, anche quando ci sono molte risorse gratuite (ad esempio, non ci sono altri utenti simultanei), Spark non può assegnare più di 5 executor per la sessione Livy.
#### Altre note
È buona prassi interrompere il kernel Jupyter quando si smette di usare un notebook. Ciò consentirà di liberare risorse che altri utenti del notebook potranno utilizzare immediatamente, senza dover attendere la scadenza del kernel (spegnimento automatico).
### Problemi comuni
Anche quando si seguono le linee guida, è possibile che si verifichino alcuni problemi.
#### Sessione non trovata
Se provi a eseguire un paragrafo del notebook anche se la sessione Livy è già stata terminata, verrà visualizzato il messaggio seguente. Per attivare la sessione Livy, devi riavviare il kernel Jupyter scegliendo **Kernel** >**Restart (Riavvia)** nel menu Jupyter, quindi eseguire nuovamente il paragrafo del notebook.
```
An error was encountered:
Invalid status code '404' from http://localhost:8998/sessions/13 with error payload: "Session '13' not found."
```
#### Risorse YARN insufficienti
Se provi a eseguire un paragrafo del notebook anche se il cluster Spark non dispone di risorse sufficienti per avviare una nuova sessione Livy, verrà visualizzato il messaggio seguente. Seguendo le linee guida è spesso possibile evitare questo problema, tuttavia potrebbe verificarsi. Per risolvere il problema, puoi verificare se sono presenti sessioni Livy attive non necessarie. In caso affermativo, sarà necessario terminarle per liberare le risorse del cluster. Per ulteriori informazioni, consulta la prossima sezione.
```
Warning: The Spark session does not have enough YARN resources to start.
The code failed because of a fatal error:
Session 16 did not start up in 60 seconds..
Some things to try:
a) Make sure Spark has enough available resources for Jupyter to create a Spark context.
b) Contact your Jupyter administrator to make sure the Spark magics library is configured correctly.
c) Restart the kernel.
```
### Monitoraggio e debug
In questa sezione vengono descritte le tecniche per il monitoraggio delle risorse e delle sessioni.
#### Monitoraggio e debug dell'allocazione delle risorse nel cluster
È possibile visualizzare l'interfaccia utente di Spark per monitorare il numero di risorse allocate per ogni sessione Livy e quali sono le configurazioni Spark effettive sul processo. Per attivare l'interfaccia utente di Spark, consulta [Abilitazione dell'interfaccia utente Web di Apache Spark per endpoint di sviluppo](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-dev-endpoints.html).
(Facoltativo) Se è necessaria una visualizzazione in tempo reale dell'interfaccia utente di Spark, puoi configurare un tunnel SSH sul server di cronologia Spark in esecuzione sul cluster Spark.
```
ssh -i -N -L 8157::18080 glue@
```
Apri http://localhost:8157 nel browser per visualizzare l'interfaccia utente di Spark in locale.
#### Sessioni libere Livy non necessarie
Consulta queste procedure per arrestare le sessioni Livy non necessarie da un notebook o da un cluster Spark.
**(a). Terminare le sessioni Livy da un notebook**
Puoi chiudere il kernel su un notebook Jupyter per terminare sessioni Livy non necessarie.
**(b). Terminare le sessioni Livy da un cluster Spark**
Se sono ancora in esecuzione sessioni Livy non necessarie, puoi arrestare le sessioni Livy nel cluster Spark.
Come prerequisito per eseguire questa procedura, è necessario configurare la chiave pubblica SSH per l'endpoint di sviluppo.
Per accedere al cluster Spark, esegui il comando seguente:
```
$ ssh -i glue@
```
Per visualizzare le sessioni attive Livy, esegui il comando seguente:
```
$ yarn application -list
20/09/25 06:22:21 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/172.38.106.206:8032
Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):2
Application-Id Application-Name Application-Type User Queue State Final-State Progress Tracking-URL
application_1601003432160_0005 livy-session-4 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-4-130.ec2.internal:41867
application_1601003432160_0004 livy-session-3 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-179-185.ec2.internal:33727
```
Puoi quindi chiudere la sessione Livy con il seguente comando:
```
$ yarn application -kill application_1601003432160_0005
20/09/25 06:23:38 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/255.1.106.206:8032
Killing application application_1601003432160_0005
20/09/25 06:23:39 INFO impl.YarnClientImpl: Killed application application_1601003432160_0005
```