AWS Cloud9 non è più disponibile per i nuovi clienti. I clienti esistenti di AWS Cloud9 possono continuare a utilizzare il servizio come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
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à.
# Lavorare con Builder, Runner e Debugger nell'IDE AWS Cloud9
Un *builder* indica all' AWS Cloud9 Integrated Development Environment (IDE) come creare i file di un progetto. Un *runner* indica all' AWS Cloud9 IDE come eseguire file di un tipo specifico. Un'esecuzione può utilizzare un *debugger* per aiutare a individuare eventuali problemi nel codice sorgente dei file.
È possibile utilizzare l' AWS Cloud9 IDE per creare, eseguire ed eseguire il debug del codice nei seguenti modi:
+ Uso di un builder per creare i file del progetto. Per ulteriori informazioni, consulta [Build Your Project's Files](#build-run-debug-build).
+ Uso di un'esecuzione per eseguire il codice (ed eventualmente eseguirne il debug). Per ulteriori informazioni, consulta [Build, Run and Debug Support integrato e](#build-run-debug-supported) [Run Your Code.](#build-run-debug-run)
+ Modifica di un'esecuzione integrata per eseguire il codice (ed eventualmente eseguirne il debug) in modo diverso dalla sua definizione originale. Per ulteriori informazioni, consulta [Change a Built-In Runner](build-run-debug-change-runner.md).
+ Uso di un'esecuzione per eseguire il codice (ed eventualmente eseguirne il debug) con una combinazione personalizzata di nome di file, opzioni di riga di comando, modalità di debug, directory di lavoro corrente e variabili di ambiente. Per ulteriori informazioni, consulta [Creare una configurazione di esecuzione](build-run-debug-create-run-config.md).
+ Creazione di un builder o un'esecuzione. Per ulteriori informazioni, consulta [Create a Builder o Runner](#build-run-debug-create-builder-runner).
## Supporto integrato per creazione, esecuzione e debug
L' AWS Cloud9 IDE fornisce supporto integrato per la creazione, l'esecuzione e il debug di codice per diverse lingue. Per un elenco completo, consulta [Supporto linguaggio](language-support.md).
Il supporto integrato per la creazione è disponibile nella barra dei menu, tramite i comandi **Run** (Esegui), **Build System** (Sistema creazione) e **Run** (Esegui), **Build** (Costruisci). Per aggiungere il supporto per un linguaggio o uno strumento di programmazione non elencati, consulta [Creazione di un builder o di un'esecuzione](#build-run-debug-create-builder-runner).
Il supporto integrato per l'esecuzione è disponibile con il pulsante **Run** (Esegui) e nella barra dei menu tramite i comandi **Run** (Esegui), **Run With** (Esegui con) e **Run** (Esegui), **Run Configurations** (Configurazioni esecuzione). Per aggiungere il supporto per un linguaggio o uno strumento di programmazione non elencati, consulta [Creazione di un builder o di un'esecuzione](#build-run-debug-create-builder-runner) e [Creazione di una configurazione dell'esecuzione](build-run-debug-create-run-config.md).
Il supporto integrato per il debug è disponibile tramite la finestra **Debugger**. Per visualizzare la finestra **Debugger**, seleziona il pulsante **Debugger**. Se il pulsante **Debugger** non è visibile, seleziona **Window (Finestra)**, **Debugger** nella barra dei menu.
## Creazione dei file del progetto
1. Apri un file corrispondente al codice che desideri creare.
1. Nella barra dei menu, selezionare **Run, Build System (Esegui, Sistema creazione)**, quindi seleziona il nome del builder da utilizzare, se non è già selezionato. Se il builder che si desidera utilizzare non è elencato, interrompere questa procedura, completare i passaggi descritti in [Creazione di un builder o di un'esecuzione](#build-run-debug-create-builder-runner), quindi tornare a questa procedura.
1. Selezionare **Run, Build (Esegui, Crea)**.
## Esecuzione del codice
1. Apri un file corrispondente al codice che desideri eseguire, se non è già aperto e selezionato.
1. Nella barra dei menu, procedi in uno dei seguenti modi:
+ Per eseguire il codice con l'esecuzione integrata corrispondente più vicina, selezionare **Run, Run (Esegui, Esegui)**. Se AWS Cloud9 non riesci a trovarne uno, questo comando è disabilitato.
+ Per eseguire il codice con la configurazione di esecuzione utilizzata l' AWS Cloud9 ultima volta, scegli **Esegui, Esegui per ultimo**.
+ Per eseguire il codice con una determinata esecuzione, selezionare **Run, Run With (Esegui, Esegui con)**, quindi selezionare il nome dell'esecuzione. Se l'esecuzione che si desidera utilizzare non è elencata, interrompere questa procedura, completare i passaggi descritti in [Creazione di un builder o di un'esecuzione](#build-run-debug-create-builder-runner), quindi tornare a questa procedura.
+ Per eseguire il codice tramite una specifica esecuzione con una combinazione personalizzata di nome di file, opzioni di riga di comando, modalità di debug, directory di lavoro corrente e variabili di ambiente, selezionare **Run, Run Configurations (Esegui, Configurazioni esecuzione)**, quindi il nome della configurazione dell'esecuzione. Nella scheda di configurazione dell'esecuzione visualizzata, selezionare **Runner: Auto (Esecuzione: auto)**, l'esecuzione che si desidera utilizzare, quindi **Run (Esegui)**. Se l'esecuzione che si desidera utilizzare non è elencata, interrompere questa procedura, completare i passaggi descritti in [Creazione di un builder o di un'esecuzione](#build-run-debug-create-builder-runner), quindi tornare a questa procedura.
## Esecuzione del debug del codice
1. Nella scheda di configurazione dell'esecuzione del codice, selezionare **Run in Debug Mode (Esegui in modalità debug)**. L'icona bug diventa verde su sfondo bianco. Per ulteriori dettagli, consulta [Esecuzione del codice](#build-run-debug-run) e [Creazione di una configurazione dell'esecuzione](build-run-debug-create-run-config.md).
1. Imposta i punti di interruzione nel codice in corrispondenza dei quali desideri interrompere durante l'esecuzione, come segue:
1. Apri tutti i file in cui desideri impostare un punto di interruzione.
1. In ogni punto in un file in cui vuoi impostare un'interruzione, seleziona l'area vuota nel margine a sinistra del numero di riga. Viene visualizzato un cerchio rosso.
Per rimuovere un punto di interruzione, selezionalo nel margine.
Per disattivare un punto di interruzione invece di rimuoverlo, nella finestra **Debugger**, in **Breakpoints (Punti interruzione)**, deselezionare la casella corrispondente al punto di interruzione che si desidera disattivare. Per attivare di nuovo il punto di interruzione, seleziona casella che hai deselezionato.
Per disattivare tutti i punti di interruzione contemporaneamente, nella finestra **Debugger**, selezionare **Deactivate All Breakpoints(Disattiva tutti i punti di interruzione)**. Per attivare di nuovo tutti i punti di interruzione, selezionare **Activate All Breakpoints (Attiva tutti i punti di interruzione)**.
Se la finestra **Debugger** non è visibile, selezionare il pulsante **Debugger**. Se il pulsante **Debugger** non è visibile, nella barra dei menu selezionare **Window (Finestra)**, **Debugger**.
1. Imposta le espressioni di controllo delle quali vuoi ottenere il valore nel punto in cui un'esecuzione si interrompe, come segue:
1. Nella finestra **Debugger**, in **Watch Expressions (Espressioni di controllo)**, selezionare **Type an expression here (Digita un'espressione qui)**.
1. Digita l'espressione che desideri controllare, quindi premi `Enter`.
Per modificare un'espressione di controllo esistente, fare clic con il pulsante destro del mouse sull'espressione e selezionare **Edit Watch Expression (Modifica espressione di controllo)**. Digita la modifica, quindi premi `Enter`.
Per rimuovere un'espressione di controllo esistente, fare clic con il pulsante destro del mouse sull'espressione e selezionare **Remove Watch Expression (Rimuovi espressione di controllo)**.
1. Eseguire il codice come descritto in [Esecuzione del codice](#build-run-debug-run).
Ogni volta che un'esecuzione viene interrotta, puoi anche posizionare il puntatore su una parte di codice visualizzata (ad esempio, una variabile) per mostrare tutte le informazioni disponibili al riguardo in una descrizione comando.
# Modifica di un'esecuzione integrata
Questo passaggio mostra come modificare un Built-In Runner per eseguire (e, facoltativamente, eseguire il debug) del codice in un modo diverso da come era stato originariamente definito.
1. Nella barra dei menu, selezionare **Run, Run With (Esegui, Esegui con),**, quindi selezionare l'esecuzione integrata da modificare.
1. Arrestare il tentativo di eseguire il codice da parte dell'esecuzione selezionando **Stop (Arresta)** nella scheda di configurazione dell'esecuzione visualizzata.
1. Selezionare **Runner: My Runner (Esecuzione: la mia esecuzione)**, dove **My Runner (La mia esecuzione)** è il nome dell'esecuzione da modificare, quindi scegliere **Edit Runner (Modifica esecuzione)**.
1. Nella scheda **My Runner.run** visualizzata, modificare la definizione corrente dell'esecuzione. Consulta [Definizione di un builder o di un'esecuzione](build-run-debug-define-builder-runner.md).
1. Selezionare **File, Save As (File, Salva come)**. Salvate il file con lo stesso nome (**My Runner.run**) nella `my-environment/.c9/runners` directory, dove si `my-environment` trova il nome del vostro ambiente di sviluppo. AWS Cloud9
**Nota**
Le modifiche apportate a un'esecuzione integrata si applicano solo all'ambiente in cui sono state effettuate. Per applicare le modifiche a un ambiente separato, apri l'altro ambiente e segui le fasi precedenti per aprire, modificare e salvare le stesse modifiche apportate all'esecuzione integrata.
# Creazione di una configurazione dell'esecuzione
Questo passaggio mostra come eseguire (e facoltativamente, eseguire il debug) del codice con una combinazione personalizzata di nome file, opzioni della riga di comando, modalità di debug, directory di lavoro corrente e variabili di ambiente.
Nella barra dei menu, selezionare **Run, Run Configurations, New Run Configuration (Esegui, Configurazioni esecuzione, Nuova configurazione esecuzione)**. Nella scheda di configurazione dell'esecuzione che viene visualizzata, procedi nel seguente modo:
1. Nella casella accanto a **Run (Esegui)** e a **Restart (Riavvia)**, digitare il nome visualizzato nel menu **Run, Run Configurations (Esegui, Configurazioni esecuzione)** per questa configurazione dell'esecuzione.
1. Nella casella **Command (Comando)**, digitare le opzioni personalizzate della riga di comando che si desidera utilizzare.
1. Per applicare le impostazioni di debug predefinite dell'esecuzione a questa configurazione, selezionare **Run in Debug Mode (Esegui in modalità debug)**. L'icona bug diventa verde su sfondo bianco.
1. Se si desidera che la configurazione dell'esecuzione utilizzi una specifica directory di lavoro, selezionare **CWD**, la directory da utilizzare, quindi **Select (Seleziona)**.
1. Se si desidera che la configurazione dell'esecuzione utilizzi variabili di ambiente specifiche, selezionare **ENV**, quindi digitare il nome e il valore di ogni variabile di ambiente.
Per usare questa configurazione dell'esecuzione, apri il file corrispondente al codice che vuoi eseguire. Selezionare **Run, Run Configurations (Esegui, Configurazioni esecuzione)** nella barra dei menu, quindi selezionare il nome della configurazione dell'esecuzione. Nella scheda di configurazione dell'esecuzione visualizzata, selezionare **Runner: Auto (Esecuzione: auto)**, l'esecuzione da utilizzare, quindi **Run (Esegui)**.
**Nota**
Qualsiasi esecuzione creata si applica solo all'ambiente in cui è stata creata la configurazione dell'esecuzione. Per aggiungere la configurazione dell'esecuzione a un ambiente separato, apri l'altro ambiente e segui le fasi precedenti per creare la stessa configurazione dell'esecuzione in tale ambiente.
## Creazione di un builder o un'esecuzione
Questo passaggio mostra come creare il tuo builder o runner.
1. Per creare un builder, nella barra dei menu selezionare **Run, Build System, New Build System (Esegui, Sistema creazione, Nuovo sistema creazione)**. Per creare un'esecuzione, nella barra dei menu selezionare **Run, Run With, New Runner (Esegui, Esegui con, Nuova esecuzione)**.
1. Nella scheda del builder (denominata **My Builder.build (Mio builder.build)**) o in quella dell'esecuzione (denominata **My Runner.run (Mia esecuzione.run)**) visualizzata, definire il builder o l'esecuzione. Consulta [Definizione di un builder o di un'esecuzione](build-run-debug-define-builder-runner.md).
1. Dopo aver definito il builder o l'esecuzione, selezionare **File, Save As (File, Salva con nome)**. Per un builder, salva il file con l'estensione `.build` nella directory `my-environment/.c9/builders`, dove `my-environment` è il nome dell'ambiente. Per un'esecuzione, salva il file con l'estensione `.run` nella directory `my-environment/.c9/runners`, dove `my-environment` è il nome dell'ambiente. Il nome del file che specifichi sarà visualizzato nel menu **Run, Build System (Esegui, Sistema creazione)** per un builder oppure **Run, Run With (Esegui, Esegui con)** per un'esecuzione. Pertanto, a meno che non specifichi un nome di file diverso, per impostazione predefinita il nome visualizzato sarà **My Builder (Mio builder)** o **My Runner (Mia esecuzione)**.
Per utilizzare il builder o l'esecuzione, consulta [Creazione dei file del progetto](#build-run-debug-build) o [Esecuzione del codice](#build-run-debug-run).
**Nota**
Qualsiasi builder o esecuzione creati si applicano solo all'ambiente in cui sono stati creati. Per aggiungere il builder o l'esecuzione a un ambiente separato, apri altro ambiente e segui le fasi precedenti per creare lo stesso builder o la stessa esecuzione in tale ambiente.
# Definizione di un builder o un'esecuzione
Questo argomento mostra come definire un builder o un runner. Prima di definire un builder o un runner, assicurati di aver [creato un builder o un](build-run-debug.md#build-run-debug-create-builder-runner) runner.
Nella scheda del builder o dell'esecuzione visualizzata, utilizza JSON per definire l'esecuzione o il builder. Inizia con il codice seguente come modello.
Per un builder, inizia con questo codice.
```
{
"cmd": [],
"info": "",
"env": {},
"selector": ""
}
```
Per un'esecuzione, inizia con questo codice.
```
{
"cmd": [],
"script": "",
"working_dir": "",
"info": "",
"env": {},
"selector": "",
"debugger": "",
"debugport": ""
}
```
Nel codice precedente:
+ `cmd`: rappresenta un elenco di stringhe separate da virgole da eseguire come singolo comando. AWS Cloud9
Quando AWS Cloud9 viene eseguito questo comando, ogni stringa nell'elenco verrà separata da un singolo spazio. Ad esempio, AWS Cloud9 verrà eseguito `"cmd": [ "ls", "$file", "$args"]` come`ls $file $args`, dove AWS Cloud9 verrà sostituito `$file` con il percorso completo del file corrente e `$args` con qualsiasi argomento inserito dopo il nome del file. Per ulteriori informazioni, consulta l'elenco delle variabili supportate più avanti in questa sezione.
+ `script`: rappresenta uno script Bash (che in base alla necessità può essere specificato anche come una serie di righe per la leggibilità) che l'esecuzione esegue nel terminale.
+ `working_dir`: rappresenta la directory da cui verrà eseguita l'esecuzione.
+ `info`: rappresenta qualsiasi stringa di testo che desideri visualizzare per l'utente all'inizio dell'esecuzione. Questa stringa può contenere variabili, ad esempio`Running $project_path$file_name...`, dove AWS Cloud9 verrà sostituita `$project_path` con il percorso della directory del file corrente e `$file_name` con la parte relativa al nome del file corrente. Consulta l'elenco delle variabili supportate più avanti in questa sezione.
+ `env`: Rappresenta qualsiasi matrice di argomenti della riga di comando AWS Cloud9 da utilizzare, ad esempio:
```
"env": {
"LANG": "en_US.UTF-8",
"SHLVL": "1"
}
```
+ `selector`: Rappresenta qualsiasi espressione regolare che si desidera utilizzare AWS Cloud9 per identificare i nomi di file che si applicano a questo runner. Ad esempio, potresti specificare `source.py` per i file Python.
+ `debugger`: rappresenta il nome di qualsiasi debugger disponibile che si desidera AWS Cloud9 utilizzare e compatibile con questo runner. Ad esempio, potresti specificare `v8` per il debugger V8.
+ `debugport`: rappresenta il numero di porta che si desidera AWS Cloud9 utilizzare durante il debug. Ad esempio, potresti specificare `15454` per il numero di porta da utilizzare.
Nella tabella seguente sono riportate le variabili che puoi utilizzare.
****
| **Variabile** | **Descrizione** |
| --- | --- |
| `$file_path` | Directory del file corrente, ad esempio `/home/ec2-user/environment` o `/home/ubuntu/environment`. |
| `$file` | Percorso completo del file corrente, ad esempio `/home/ec2-user/environment/hello.py` o `/home/ubuntu/environment/hello.py`. |
| `$args` | Qualsiasi argomento inserito dopo il nome di file, ad esempio `"5" "9"`. |
| `$file_name` | Porzione del nome del file corrente, ad esempio `hello.py`. |
| `$file_extension` | Estensione del file corrente, ad esempio `py`. |
| `$file_base_name` | Nome del file corrente senza estensione del file, ad esempio `hello`. |
| `$packages` | Percorso completo della cartella dei pacchetti. |
| `$project` | Percorso completo della cartella del progetto corrente. |
| `$project_path` | Directory del file di progetto corrente, ad esempio `/home/ec2-user/environment/` o `/home/ubuntu/environment/`. |
| `$project_name` | Nome del file di progetto corrente senza estensione del file, ad esempio `my-demo-environment`. |
| `$project_extension` | Estensione del file di progetto corrente. |
| `$project_base_name` | Nome del file di progetto corrente, senza estensione. |
| `$hostname` | Nome host dell'ambiente, ad esempio `192.0.2.0`. |
| `$hostname_path` | Nome host dell'ambiente con il relativo percorso del file di progetto, ad esempio `https://192.0.2.0/hello.js`. |
| `$url` | URL completo per accedere all'ambiente, ad esempio `https://192.0.2.0.`. |
| `$port` | Porta assegnata all'ambiente, ad esempio `8080`. |
| `$ip` | Indirizzo IP per l'esecuzione di un processo nell'ambiente, ad esempio `0.0.0.0`. |
Ad esempio, il seguente file di builder denominato `G++.build` definisce un builder per GCC che esegue il comando ** `g++` ** con l'opzione `-o` per compilare il file corrente (ad esempio, `hello.cpp`) in un modulo oggetto. Quindi collega il modulo oggetto in un programma con lo stesso nome del file corrente (ad esempio, `hello`). In questo caso il comando equivalente è `g++ -o hello hello.cpp`.
```
{
"cmd": [ "g++", "-o", "$file_base_name", "$file_name" ],
"info": "Compiling $file_name and linking to $file_base_name...",
"selector": "source.cpp"
}
```
Come altro esempio, il seguente file di esecuzione denominato `Python.run` definisce un'esecuzione che utilizza Python per eseguire il file corrente con gli argomenti forniti. Ad esempio, se il file corrente è denominato `hello.py` e sono stati forniti gli argomenti `5` e `9`, il comando equivalente è `python hello.py 5 9`.
```
{
"cmd": [ "python", "$file_name", "$args" ],
"info": "Running $file_name...",
"selector": "source.py"
}
```
Infine, il seguente file di esecuzione denominato `Print Run Variables.run` definisce un'esecuzione che restituisce semplicemente il valore di ogni variabile disponibile e quindi si arresta.
```
{
"info": "file_path = $file_path, file = $file, args = $args, file_name = $file_name, file_extension = $file_extension, file_base_name = $file_base_name, packages = $packages, project = $project, project_path = $project_path, project_name = $project_name, project_extension = $project_extension, project_base_name = $project_base_name, hostname = $hostname, hostname_path = $hostname_path, url = $url, port = $port, ip = $ip"
}
```