

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

# Tutorial: configura un PyCharm professionista con un endpoint di sviluppo
<a name="dev-endpoint-tutorial-pycharm"></a>

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
<a name="dev-endpoint-tutorial-pycharm-connect"></a>

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 <key_file_name> -C "<your_email_address>"
     ```
   + 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
<a name="dev-endpoint-tutorial-pycharm-deploy"></a>

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
<a name="dev-endpoint-tutorial-pycharm-interpreter"></a>

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
<a name="dev-endpoint-tutorial-pycharm-debug-run"></a>

Per eseguire lo script:
+ Nel riquadro sinistro, fai clic con il pulsante destro del mouse sul nome del file e scegli **Esegui** ''. *<filename>*

  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.