AWS Cloud9 ya no está disponible para nuevos clientes. Los clientes existentes de AWS Cloud9 pueden seguir utilizando el servicio con normalidad. [Más información](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Trabajar con compiladores, ejecutores y depuradores en el IDE AWS Cloud9
<a name="build-run-debug"></a>

Un *constructor* indica al entorno de desarrollo AWS Cloud9 integrado (IDE) cómo crear los archivos de un proyecto. Un *ejecutor* indica al AWS Cloud9 IDE cómo ejecutar archivos de un tipo específico. Un ejecutor puede utilizar un *depurador* para ayudar a encontrar cualquier problema en el código fuente de los archivos.

Puedes usar el AWS Cloud9 IDE para compilar, ejecutar y depurar el código de las siguientes maneras:
+ Utilice un compilador para compilar los archivos del proyecto. Para obtener más información, consulte [Build Your Project's Files](#build-run-debug-build).
+ Utilice a un ejecutor para ejecutar (y, de forma opcional, depurar) el código. Para obtener más información, consulte [Built-In Build, Run, and Debug Support](#build-run-debug-supported) y [Run Your Code](#build-run-debug-run).
+ Cambie un ejecutor integrado que ejecute (y, de forma opcional, depure) el código de una forma diferente a la que se ha definido originalmente. Para obtener más información, consulte [Change a Built-In Runner](build-run-debug-change-runner.md).
+ Utilice un ejecutor que ejecute (y, de forma opcional, depure) el código con una combinación personalizada de nombre de archivo, opciones de línea de comandos, modo de depuración, directorio de trabajo actual y variables de entorno. Para obtener más información, consulte [Create a Run Configuration](build-run-debug-create-run-config.md).
+ Cree su propio compilador o ejecutor. Para obtener más información, consulte [Create a Builder or Runner](#build-run-debug-create-builder-runner).

## Soporte integrado de compilación, ejecución y depuración
<a name="build-run-debug-supported"></a>

El AWS Cloud9 IDE proporciona soporte integrado para compilar, ejecutar y depurar código para varios lenguajes. Para obtener una lista completa, consulte [Lenguajes compatibles](language-support.md).

El soporte de compilación integrado se encuentra disponible en la barra de menús con los comandos de menú **Run** (Ejecutar), **Build System** (Sistema de compilación) y **Run** (Ejecutar), **Build** (Compilar). Para añadir compatibilidad con un lenguaje de programación o una herramienta que no se encuentren en la lista, consulte la sección [Crear un compilador o ejecutor](#build-run-debug-create-builder-runner).

El soporte integrado se encuentra disponible con el botón **Run** (Ejecutar) y en la barra de menús con los comandos de menú **Run** (Ejecutar), **Run With** (Ejecutar con) y **Run** (Ejecutar), **Run Configurations** (Configuraciones de ejecución). Para añadir compatibilidad con un lenguaje de programación o una herramienta que no se encuentren en la lista, consulte [Crear un compilador o ejecutor](#build-run-debug-create-builder-runner) y [Crear una configuración de ejecución](build-run-debug-create-run-config.md).

El soporte de depuración integrado se encuentra disponible a través de la ventana **Debugger (Depurador)**. Para ver la ventana **Debugger (Depurador)**, elija el botón **Debugger (Depurador)**. Si el botón **Debugger (Depurador)** no es visible, elija **Window (Ventana)**, **Debugger (Depurador)** en la barra de menús.

## Compilar los archivos del proyecto
<a name="build-run-debug-build"></a>

1. Abra un archivo que se corresponda con el código que desea compilar.

1. En la barra de menús, elija **Run, Build System (Ejecutar, Sistema de compilación)** y, a continuación, elija el nombre del compilador que va a utilizar si aún no lo ha elegido. Si el compilador que desea utilizar no se encuentra en la lista, detenga este procedimiento, realice los pasos que se indican en [Crear un compilador o ejecutor](#build-run-debug-create-builder-runner) y, a continuación, vuelva a este procedimiento.

1. Elija **Run, Build (Ejecutar, Compilar)**.

## Ejecutar el código
<a name="build-run-debug-run"></a>

1. Abra un archivo que se corresponda con el código que desea ejecutar, si el archivo aún no está abierto y seleccionado.

1. En la barra de menús, realice una de las siguientes operaciones:
   + Para ejecutar el código con el ejecutor integrado de mayor coincidencia, elija **Run, Run (Ejecutar, Ejecutar)**. Si AWS Cloud9 no puede encontrar ninguno, este comando está deshabilitado.
   + Para ejecutar el código con la configuración de ejecución utilizada por AWS Cloud9 última vez, seleccione **Ejecutar, ejecutar por última vez**.
   + Para ejecutar el código con un ejecutor específico, elija **Run, Run With (Ejecutar, Ejecutar con)** y, a continuación, elija el nombre del ejecutor. Si el ejecutor que desea utilizar no se encuentra en la lista, detenga este procedimiento, realice los pasos que se indican en [Crear un compilador o ejecutor](#build-run-debug-create-builder-runner) y, a continuación, vuelva a este procedimiento.
   + Para ejecutar el código con un ejecutor específico con una combinación personalizada de nombre de archivo, opciones de línea de comandos, modo de depuración, directorio de trabajo actual y variables de entorno, elija **Run, Run Configurations (Ejecutar, Configuraciones de ejecución)** y, a continuación, elija el nombre de la configuración de ejecución. Si se abre la pestaña de la configuración de ejecución, elija **Runner: Auto (Ejecutor: Auto)**, elija el ejecutor que desea utilizar y, a continuación, seleccione **Run (Ejecutar)**. Si el ejecutor que desea utilizar no se encuentra en la lista, detenga este procedimiento, realice los pasos que se indican en [Crear un compilador o ejecutor](#build-run-debug-create-builder-runner) y, a continuación, vuelva a este procedimiento.

## Depurar el código
<a name="build-run-debug-debug"></a>

1. En la pestaña de configuración de ejecución del código, elija **Run in Debug Mode (Ejecutar en modo de depuración)**. El icono de error cambia a verde sobre un fondo blanco. Para obtener más información, consulte [Ejecutar el código](#build-run-debug-run) y [Crear una configuración de ejecución](build-run-debug-create-run-config.md).

1. Establezca los puntos de interrupción en el código que desee para realizar pausas durante la ejecución, tal y como se indica a continuación:

   1. Abra cada archivo en el que desea establecer un punto de interrupción.

   1. En cada punto de un archivo en el que desea establecer un punto de interrupción, elija el área en blanco del margen interior situado a la izquierda del número de línea. Aparece un círculo rojo.

      Para eliminar un punto de interrupción, elija el punto de interrupción existente en el margen interior.

      Para deshabilitar un punto de interrupción en lugar de eliminarlo, en la ventana **Debugger (Depurador)**, en **Breakpoints (Puntos de interrupción)**, desactive la casilla que se corresponde con punto de interrupción que desea deshabilitar. Para habilitar el punto de interrupción de nuevo, seleccione la casilla que ha desactivado.

      Para deshabilitar todos los puntos de interrupción a la vez, en la ventana **Debugger (Depurador)**, elija **Deactivate All Breakpoints (Desactivar todos los puntos de interrupción)**. Para habilitar de nuevo todos los puntos de interrupción, elija **Activate All Breakpoints (Activar todos los puntos de interrupción)**.

      Si la ventana **Debugger (Depurador)** no es visible, elija el botón **Debugger (Depurador)**. Si el botón **Debugger (Depurador)** no es visible, en la barra de menús, elija **Window (Ventana)**, **Debugger (Depurador)**.

1. Establezca cualquier expresión de inspección para la que desea obtener el valor en el punto en que se pone en pausa la ejecución, tal y como se indica a continuación:

   1. En la ventana **Debugger (Depurador)**, en **Watch Expressions (Expresiones de inspección)**, elija **Type an expression here (Escriba una expresión aquí)**.

   1. Escriba la expresión que desea inspeccionar y, a continuación, presione `Enter`.

      Para cambiar una expresión de observación existente, haga clic con el botón derecho del ratón en dicha expresión y, a continuación, elija **Edit Watch Expression (Editar expresión de inspección)**. Escriba el cambio y, a continuación, presione `Enter`.

      Para eliminar una expresión de inspección existente, haga clic con el botón derecho del ratón en dicha expresión y, a continuación, elija **Remove Watch Expression (Eliminar expresión de inspección)**.

1. Ejecute el código tal y como se describe en [Ejecutar el código](#build-run-debug-run).

Cada vez que una ejecución se pone en pausa, también puede detener el puntero sobre cualquier fragmento de código mostrado (por ejemplo, una variable) para ver la información disponible correspondiente en una información sobre herramientas.

# Cambiar un ejecutor integrado
<a name="build-run-debug-change-runner"></a>

Este paso le muestra cómo puede cambiar un ejecutor integrado para que ejecute (y, de forma opcional, depure) el código de una forma diferente a la que se ha definido originalmente.

1. En la barra de menús, elija **Run, Run With (Ejecutar, Ejecutar con)** y, a continuación, elija el ejecutor integrado que desea cambiar.

1. Para detener el ejecutor para que no intente ejecutar el código, elija **Stop (Detener)** en la pestaña de configuración de ejecución que se abre.

1. Elija **Runner: My Runner (Ejecutor: Mi ejecutor)**, donde **My Runner (Mi ejecutor)** es el nombre del ejecutor que desea cambiar y, a continuación, elija **Edit Runner (Editar ejecutor)**.

1. En la pestaña **My Runner.run (Mi Runner.run)** que se abre, cambie la definición actual del ejecutor. Consulte [Definir un compilador o ejecutor](build-run-debug-define-builder-runner.md).

1. Elija **File, Save As (Archivo, Guardar como)**. Guarde el archivo con el mismo nombre (**My Runner.run**) en el `my-environment/.c9/runners` directorio, donde `my-environment` aparece el nombre de su AWS Cloud9 entorno de desarrollo.

**nota**  
Los cambios que realiza en un ejecutor integrado se aplican únicamente al entorno en el que ha realizado esos cambios. Para aplicar los cambios en otro entorno, abra el otro entorno y, a continuación, siga los pasos anteriores para abrir, editar y guardar esos mismos cambios de el ejecutor integrado.

# Crear una configuración de ejecución
<a name="build-run-debug-create-run-config"></a>

Este paso le muestra cómo puede cambiar un ejecutor para que ejecute (y, de forma opcional, depure) el código con una combinación personalizada de nombre de archivo, opciones de línea de comandos, modo de depuración, directorio de trabajo actual y variables de entorno.

En la barra de menús, elija **Run, Run Configurations, New Run Configuration (Ejecutar, Configuraciones de ejecución, Nueva configuración de ejecución)**. En la pestaña de la configuración de ejecución que se abre, haga lo siguiente:

1. En el cuadro que aparece junto a **Run (Ejecutar)** y **Restart (Reiniciar)**, escriba el nombre que se mostrará en el menú **Run, Run Configurations (Ejecutar, Configuraciones de ejecución)** para esta configuración.

1. En el cuadro **Command (Comando)**, escriba las opciones de línea de comandos personalizadas que desee utilizar.

1. Para que esta configuración de ejecución utilice la configuración de depuración predefinida del ejecutor, elija **Run in Debug Mode (Ejecutar en modo de depuración)**. El icono de error cambiará a verde sobre un fondo blanco.

1. Para que esta configuración use un directorio de trabajo específico, elija **CWD**, elija el directorio que se va a usar y, a continuación, elija **Select (Seleccionar)**.

1. Para que esta configuración de ejecución utilice variables de entorno específicas, seleccione **ENV** y, a continuación, escriba el nombre y el valor de cada variable de entorno.

Para utilizar esta configuración de ejecución, abra el archivo que se corresponde con el código que desea ejecutar. Elija **Run, Run Configurations (Ejecutar, Configuraciones de ejecución)** en la barra de menús y luego elija el nombre de esta configuración de ejecución. En la pestaña de la configuración de ejecución que se abre, elija **Runner: Auto (Ejecutor: Auto)**, elija el ejecutor que desea utilizar y, a continuación, seleccione **Run (Ejecutar)**.

**nota**  
Cualquier configuración de ejecución que cree se aplica únicamente al entorno en el que creó esa configuración de ejecución. Para agregar esa configuración de ejecución a otro entorno, abra el otro entorno y, a continuación, siga los pasos anteriores para crear la misma configuración de ejecución en ese entorno.

## Crear un compilador o ejecutor
<a name="build-run-debug-create-builder-runner"></a>

En este paso se muestra cómo puede crear su propio compilador o ejecutor.

1. Para crear un compilador, en la barra de menús, elija **Run, Build System, New Build System (Ejecutar, Sistema de compilación, Nuevo sistema de compilación)**. Para crear un ejecutor, en la barra de menús, elija **Run, Run With, New Runner (Ejecutar, Ejecutar con, Nuevo ejecutor)**.

1. En la pestaña del compilador (con la etiqueta **My Builder.build [Mi Builder.build]**) o la pestaña del ejecutor (con la etiqueta **My Runner.run [Mi Runner.run]**) que aparece, defina el compilador o ejecutor. Consulte [Definir un compilador o ejecutor](build-run-debug-define-builder-runner.md).

1. Después de definir el compilador o ejecutor, elija **File, Save As (Archivo, Guardar como)**. En el caso del compilador, guarde el archivo con la extensión `.build` en el directorio `my-environment/.c9/builders`, donde `my-environment` es el nombre del entorno. En el caso del ejecutor, guarde el archivo con la extensión `.run` en el directorio `my-environment/.c9/runners`, donde `my-environment` es el nombre del entorno. El nombre del archivo que especifique será el nombre que aparece en el menú **Run, Build System (Ejecutar, Sistema de compilación)** o el menú **Run, Run With (Ejecutar, Ejecutar con)**. Por lo tanto, a menos que especifique otro nombre de archivo, de forma predeterminada el nombre de visualización será **My Builder (Mi ejecutor)** (para un compilador) o **My Runner (Mi ejecutor)** (para un ejecutor).

Para utilizar este compilador o ejecutor, consulte [Compilar los archivos del proyecto](#build-run-debug-build) o [Ejecutar el código](#build-run-debug-run).

**nota**  
Cualquier compilador o ejecutor que cree se aplica únicamente al entorno en el que ha creado ese compilador o ejecutor. Para agregar ese compilador o ejecutor a otro entorno, abra el otro entorno y, a continuación, siga los pasos anteriores para crear el mismo compilador o ejecutor en ese entorno.

# Definir un compilador o ejecutor
<a name="build-run-debug-define-builder-runner"></a>

En este tema se muestra cómo definir un compilador o un ejecutor. Antes de definir un compilador o un ejecutor, asegúrese de haber [creado un compilador o un ejecutor](build-run-debug.md#build-run-debug-create-builder-runner).



En la pestaña del compilador o ejecutor que se muestra, utilice JSON para definir el ejecutor o compilador. Comience con el siguiente código como plantilla.

Para un compilador, comience con este código.

```
{
  "cmd": [],
  "info": "",
  "env": {},
  "selector": ""
}
```

Para un ejecutor, comience con este código.

```
{
  "cmd": [],
  "script": "",
  "working_dir": "",
  "info": "",
  "env": {},
  "selector": "",
  "debugger": "",
  "debugport": ""
}
```

En el código anterior:
+  `cmd`: Representa una lista de cadenas separadas por comas que se pueden ejecutar como un AWS Cloud9 solo comando.

  Cuando AWS Cloud9 ejecute este comando, cada cadena de la lista estará separada por un único espacio. Por ejemplo, AWS Cloud9 se ejecutará `"cmd": [ "ls", "$file", "$args"]` como`ls $file $args`, donde AWS Cloud9 se `$file` reemplazará por la ruta completa del archivo actual y `$args` por cualquier argumento introducido después del nombre del archivo. Para obtener más información, consulte la lista de variables admitidas más adelante en esta sección.
+  `script`: representa un script bash (que también puede especificarse como una matriz de líneas si es necesario para facilitar la lectura) que ejecuta el ejecutor en el terminal.
+  `working_dir`: representa el directorio desde el que se ejecutará el ejecutor.
+  `info`: representa cualquier cadena de texto que desee mostrar al usuario al principio de la ejecución. Esta cadena puede contener variables, por ejemplo`Running $project_path$file_name...`, where AWS Cloud9 se `$project_path` reemplazará por la ruta del directorio del archivo actual y `$file_name` por la parte del nombre del archivo actual. Consulte la lista de variables admitidas más adelante en esta sección.
+  `env`: Representa cualquier conjunto de argumentos de línea de comandos AWS Cloud9 que se vaya a utilizar, por ejemplo:

  ```
  "env": {
    "LANG": "en_US.UTF-8",
    "SHLVL": "1"
  }
  ```
+  `selector`: Representa cualquier expresión regular que desee utilizar AWS Cloud9 para identificar los nombres de archivo que se aplican a este ejecutor. Por ejemplo, puede especificar `source.py` para los archivos de Python.
+  `debugger`: Representa el nombre de cualquier depurador disponible que desee AWS Cloud9 utilizar y que sea compatible con este ejecutor. Por ejemplo, podría especificar `v8` para el depurador de V8.
+  `debugport`: Representa el número de puerto que desea AWS Cloud9 usar durante la depuración. Por ejemplo, podría especificar `15454` para el número de puerto que se va a utilizar.

En la siguiente tabla, se muestran las variables que se pueden utilizar.


****  

|  **Variable**  |  **Descripción**  | 
| --- | --- | 
|   `$file_path`   |  El directorio del archivo actual, por ejemplo, `/home/ec2-user/environment` o `/home/ubuntu/environment`.  | 
|   `$file`   |  La ruta completa al archivo actual, por ejemplo, `/home/ec2-user/environment/hello.py` o `/home/ubuntu/environment/hello.py`.  | 
|   `$args`   |  Cualquier argumento introducido después el nombre de archivo, por ejemplo, `"5" "9"`.  | 
|   `$file_name`   |  La parte del nombre del archivo actual, por ejemplo, `hello.py`.  | 
|   `$file_extension`   |  La extensión del archivo actual, por ejemplo, `py`.  | 
|   `$file_base_name`   |  El nombre del archivo actual sin la extensión de archivo, por ejemplo, `hello`.  | 
|   `$packages`   |  La ruta completa a la carpeta de los paquetes.  | 
|   `$project`   |  La ruta completa a la carpeta del proyecto actual.  | 
|   `$project_path`   |  El directorio del archivo del proyecto actual, por ejemplo, `/home/ec2-user/environment/` o `/home/ubuntu/environment/`.  | 
|   `$project_name`   |  El nombre del archivo del proyecto actual sin la extensión de archivo, por ejemplo, `my-demo-environment`.  | 
|   `$project_extension`   |  La extensión del archivo del proyecto actual.  | 
|   `$project_base_name`   |  El nombre del archivo del proyecto actual sin la extensión.  | 
|   `$hostname`   |  El nombre de anfitrión del entorno, como, por ejemplo, `192.0.2.0`.  | 
|   `$hostname_path`   |  El nombre de anfitrión del entorno con la ruta relativa al archivo del proyecto, como, por ejemplo, `https://192.0.2.0/hello.js`.  | 
|   `$url`   |  La URL completa para acceder al entorno, como, por ejemplo, `https://192.0.2.0.`.  | 
|   `$port`   |  El puerto asignado al entorno, como, por ejemplo, `8080`.  | 
|   `$ip`   |  La dirección IP para ejecutar un proceso en el entorno, como, por ejemplo, `0.0.0.0`.  | 

Por ejemplo, el siguiente archivo del compilador denominado `G++.build` define un compilador de GCC que ejecuta el comando ** `g++` ** con la opción `-o` para compilar el archivo actual (por ejemplo, `hello.cpp`) en un módulo de objetos. A continuación, vincula el módulo de objetos a un programa con el mismo nombre que el archivo actual (por ejemplo, `hello`). Aquí, el comando equivalente es `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"
}
```

Como otro ejemplo, el siguiente archivo del ejecutor denominado `Python.run` define un ejecutor que utiliza Python para ejecutar el archivo actual con los argumentos que se han proporcionado. Por ejemplo, si el nombre del archivo actual es `hello.py` y se han proporcionado los argumentos `5` y `9` , el comando equivalente es `python hello.py 5 9`.

```
{
  "cmd": [ "python", "$file_name", "$args" ],
  "info": "Running $file_name...",
  "selector": "source.py"
}
```

Por último, el siguiente archivo del ejecutor denominado `Print Run Variables.run` define un ejecutor que simplemente genera el valor de cada variable disponible y, a continuación, se detiene.

```
{
  "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"
}
```