AWS Cloud9 não está mais disponível para novos clientes. Os clientes atuais do AWS Cloud9 podem continuar usando o serviço normalmente. [Saiba mais](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Trabalhando com construtores, executores e depuradores no IDE AWS Cloud9
<a name="build-run-debug"></a>

Um *construtor* instrui o Ambiente de Desenvolvimento AWS Cloud9 Integrado (IDE) a criar os arquivos de um projeto. Um *executor* instrui o AWS Cloud9 IDE a executar arquivos de um tipo específico. Um executor pode usar um *depurador* para ajudar a encontrar problemas no código-fonte dos arquivos.

Você pode usar o AWS Cloud9 IDE para criar, executar e depurar seu código das seguintes formas:
+ Use um compilador para compilar os arquivos do projeto. Para obter mais informações, consulte [Compilar os arquivos do projeto](#build-run-debug-build).
+ Use um executor para executar (e, opcionalmente, para depurar) o código. Para obter mais informações, consulte [Suporte à compilação, execução e depuração integradas](#build-run-debug-supported) e [Executar o código](#build-run-debug-run).
+ Altere um executor integrado para executar (e, opcionalmente, para depurar) o código de forma diferente daquela definida originalmente. Para obter mais informações, consulte [Alterar um executor integrado](build-run-debug-change-runner.md).
+ Use um executor para executar (e, opcionalmente, para depurar) o código com um combinação personalizada de nome de arquivo, opções da linha de comando, modo de depuração, diretório de trabalho atual e variáveis de ambiente. Para obter mais informações, consulte [Criar uma configuração de execução](build-run-debug-create-run-config.md).
+ Crie o seu próprio compilador ou executor. Para obter mais informações, consulte [Criar um compilador ou executor](#build-run-debug-create-builder-runner).

## Suporte à compilação, execução e depuração integradas
<a name="build-run-debug-supported"></a>

O AWS Cloud9 IDE fornece suporte incorporado para criar, executar e depurar código para várias linguagens. Para obter uma lista completa, consulte [Suporte às linguagens](language-support.md).

O suporte à compilação integrada está disponível na barra de menu nos comandos **Run** (Executar), **Build System** (Compilar sistema) e **Run** (Executar), **Build** (Compilar). Para adicionar suporte a uma linguagem de programação ou ferramenta que não está listada, consulte [Criar um compilador ou executor](#build-run-debug-create-builder-runner).

O suporte à execução integrada está disponível no botão **Run** (Executar) e na barra de menu nos comandos **Run** (Executar), **Run With** (Executar com) e **Run** (Executar), **Run Configurations** (Configurações de execução). Para adicionar suporte a uma linguagem de programação ou ferramenta que não está listada, consulte [Criar um compilador ou executor](#build-run-debug-create-builder-runner) e [Criar uma configuração de execução](build-run-debug-create-run-config.md).

O suporte à depuração integrada está disponível por meio da janela **Debugger (Depurador)**. Para exibir a janela **Debugger (Depurador)**, selecione o botão **Debugger (Depurador)**. Se o botão **Debugger (Depurador)** não estiver visível, selecione **Window (Janela)**, **Debugger (Depurador)** na barra de menus.

## Compilar os arquivos do projeto
<a name="build-run-debug-build"></a>

1. Abra um arquivo correspondente ao código que deseja compilar.

1. Na barra de menus, selecione **Run, Build System (Executar, Sistema de compilação)** e, em seguida, escolha o nome do compilador para usar, caso ainda não tenha sido escolhido. Se o compilador que deseja usar não estiver listado, interrompa esse procedimento, conclua as etapas em [Criar um compilador ou executor](#build-run-debug-create-builder-runner) e, em seguida, retorne para esse procedimento.

1. Selecione **Run, Build (Executar, Compilar)**.

## Executar o código
<a name="build-run-debug-run"></a>

1. Abra um arquivo correspondente ao código que deseja executar, caso ainda não esteja aberto e selecionado.

1. Na barra de menus, selecione um dos seguintes:
   + Para executar o código com o executor integrado correspondente mais próximo, selecione **Run, Run (Executar, Executar)**. Se AWS Cloud9 não conseguir encontrar um, esse comando será desativado.
   + Para executar o código com a configuração de execução usada AWS Cloud9 pela última vez, escolha **Executar, Executar por último**.
   + Para executar o código com um executor específico, selecione **Run, Run With (Executar, Executar com)** e, em seguida, escolha o nome do executor. Se o executor que deseja usar não estiver listado, interrompa esse procedimento, conclua as etapas em [Criar um compilador ou executor](#build-run-debug-create-builder-runner) e, em seguida, retorne para esse procedimento.
   + Para executar o código com um executor específico com uma combinação personalizada de nome de arquivo, opções da linha de comando, modo de depuração, diretório de trabalho atual e variáveis de ambiente, selecione **Run, Run Configurations (Executar, Configurações de execução)** e, em seguida, escolha o nome da configuração de execução. Na guia da configuração de execução exibida, selecione **Runner: Auto (Executor: automático)**, escolha o executor que deseja usar e, em seguida, selecione **Run (Executar)**. Se o executor que deseja usar não estiver listado, interrompa esse procedimento, conclua as etapas em [Criar um compilador ou executor](#build-run-debug-create-builder-runner) e, em seguida, retorne para esse procedimento.

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

1. Na guia da configuração de execução do código, selecione **Run in Debug Mode (Executar no modo de depuração)**. O ícone de bug muda para verde em um fundo branco. Para obter mais informações, consulte [Executar o código](#build-run-debug-run) e [Criar uma configuração de execução](build-run-debug-create-run-config.md).

1. Defina os pontos de interrupção no código onde deseja pausar durante a execução, da seguinte forma:

   1. Abra cada arquivo nos quais deseja definir um ponto de interrupção.

   1. Em cada ponto em um arquivo onde deseja definir um ponto de interrupção, selecione a área em branco no gutter à esquerda do número de linha. Um círculo vermelho é exibido.

      Para remover um ponto de interrupção, selecione o ponto existente no gutter.

      Para desativar um ponto de interrupção em vez de removê-lo, na janela **Debugger (Depurador)**, em **Breakpoints (Pontos de interrupção)**, desmarque a caixa correspondente ao ponto de interrupção que deseja desativar. Para ativar o ponto de interrupção novamente, selecione a caixa que foi desmarcada.

      Para desativar todos os pontos de interrupção de uma só vez, na janela **Debugger (Depurador)**, selecione **Deactivate All Breakpoints (Desativar todos os pontos de interrupção)**. Para ativar todos os pontos de interrupção novamente, selecione **Activate All Breakpoints (Ativar todos os pontos de interrupção)**.

      Se a janela **Debugger (Depurador)** não estiver visível, selecione o botão **Debugger (Depurador)**. Se o botão **Debugger (Depurador)** não estiver visível, selecione **Window (Janela)**, **Debugger (Depurador)** na barra de menus.

1. Defina quaisquer expressões de observação para as quais deseje obter o valor no momento em que a execução pausar, da seguinte forma:

   1. Na janela **Debugger (Depurador)**, em **Watch Expressions (Expressões de observação)**, selecione **Type an expression here (Digite uma expressão aqui)**.

   1. Digite a expressão que deseja observar e, em seguida, pressione `Enter`.

      Para alterar uma expressão de observação existente, clique com o botão direito do mouse na expressão e, em seguida, selecione **Edit Watch Expression (Editar expressão de observação)**. Digite a alteração e, em seguida, pressione `Enter`.

      Para remover uma expressão de observação existente, clique com o botão direito do mouse na expressão e, em seguida, selecione **Remove Watch Expression (Remover expressão de observação)**.

1. Execute o código conforme descrito em [Executar o código](#build-run-debug-run).

Sempre que uma execução pausar, também é possível pausar o ponteiro do mouse em qualquer trecho de código exibido (por exemplo, uma variável) para mostrar as informações disponíveis sobre ele em uma dica da ferramenta.

# Alterar um executor integrado
<a name="build-run-debug-change-runner"></a>

Essa etapa mostra como você pode alterar um executor integrado para executar (e, opcionalmente, depurar) o código de forma diferente daquela definida originalmente.

1. Na barra de menus, selecione **Run, Run With (Executar, Executar com)** e, em seguida, selecione o executor integrado que deseja alterar.

1. Interrompa o executor de tentar executar o código ao escolher **Stop (Encerrar)** na guia da configuração de execução exibida.

1. Selecione **Runner: My Runner (Executor: My Runner)**, onde **My Runner** é o nome do executor que deseja alterar e, em seguida, escolha **Edit Runner (Editar executor)**.

1. Na guia **My Runner.run** exibida, altere a definição atual do executor. Consulte [Definir um compilador ou executor](build-run-debug-define-builder-runner.md).

1. Selecione **Arquivo, Salvar como**. Salve o arquivo com o mesmo nome (**My Runner.run**) no `my-environment/.c9/runners` diretório, onde `my-environment` está o nome do seu AWS Cloud9 ambiente de desenvolvimento.

**nota**  
Todas as alterações feitas em um executor integrado se aplicam somente ao ambiente em que elas foram feitas. Para aplicar as alterações em um ambiente separado, abra o outro ambiente e siga as etapas anteriores para abrir, editar e salvar as mesmas alterações nesse executor integrado.

# Criar uma configuração de execução
<a name="build-run-debug-create-run-config"></a>

Essa etapa mostra como você pode usar um executor para executar (e, opcionalmente, para depurar) o código com um combinação personalizada de nome de arquivo, opções da linha de comandos, modo de depuração, diretório de trabalho atual e variáveis de ambiente.

Na barra de menus, selecione **Run, Run Configurations, New Run Configuration (Executar, Configurações de execução, Nova configuração de execução)**. Na guia da configuração de execução exibida, faça o seguinte:

1. Na caixa ao lado de **Run (Executar)** e **Restart (Reiniciar)**, digite o nome que será exibido no menu **Run, Run Configurations (Executar, Configurações de execução)** para essa configuração de execução.

1. Na caixa **Command (Comando)**, digite qualquer opção da linha de comando personalizada que deseje usar.

1. Para que essa configuração de execução use as configurações de depuração predefinidas do executor, selecione **Run in Debug Mode (Executar no modo de depuração)**. O ícone de bug mudará para verde em um fundo branco.

1. Para que essa configuração de execução use um diretório de trabalho específico, selecione **CWD**, escolha o diretório para usar e, em seguida, selecione **Select (Selecionar)**.

1. Para que essa configuração de execução use variáveis de ambiente específicas, selecione **ENV** e, em seguida, digite o nome e o valor de cada variável de ambiente.

Para usar essa configuração de execução, abra o arquivo correspondente ao código que deseja executar. Selecione **Run, Run Configurations (Executar, Configurações de execução)** na barra de menus e, em seguida, escolha o nome dessa configuração de execução. Na guia da configuração de execução exibida, selecione **Runner: Auto (Executor: automático)**, escolha o executor que deseja usar e, em seguida, selecione **Run (Executar)**.

**nota**  
Qualquer configuração de execução criada se aplica somente ao ambiente em que ela foi criada. Para adicionar uma configuração de execução em um ambiente separado, abra o outro ambiente e siga as etapas anteriores para criar a mesma configuração de execução nesse ambiente

## Criar um compilador ou executor
<a name="build-run-debug-create-builder-runner"></a>

Esta etapa mostra como você pode criar seu compilador ou executor.

1. Para criar um compilador, na barra de menus, selecione **Run, Build System, New Build System (Executar, Sistema de compilação, Novo sistema de compilação)**. Para criar um executor, na barra de menus, selecione **Run, Run With, New Runner (Executar, Executar com, Novo executor)**.

1. Na guia do compilador (identificado como **My Builder.build**) ou na guia do executor (identificado como **My Runner.run**) exibida, defina o compilador ou o executor. Consulte [Definir um compilador ou executor](build-run-debug-define-builder-runner.md).

1. Depois de definir o compilador ou executor, selecione **File, Save As (Arquivo, Salvar como)**. Para um compilador, salve o arquivo com a extensão `.build` no diretório `my-environment/.c9/builders`, onde `my-environment` é o nome do ambiente. Para um executor, salve o arquivo com a extensão `.run` no diretório `my-environment/.c9/runners`, onde `my-environment` é o nome do ambiente. O nome de arquivo especificado será o nome exibido no menu **Run, Build System (Executar, Sistema de compilação)** (para um compilador) ou no menu **Run, Run With (Executar, Executar com)** (para um executor). Portanto, a menos que você especifique um nome de arquivo diferente, por padrão, o nome exibido será **My Builder** (para um compilador) ou **My Runner** (para um executor).

Para usar esse compilador ou executor, consulte [Compilar os arquivos do projeto](#build-run-debug-build) ou [Executar o código](#build-run-debug-run).

**nota**  
Qualquer compilador ou executor criado se aplica somente ao ambiente em que foi criado. Para adicionar o compilador ou executor em um ambiente separado, abra o outro ambiente e siga as etapas anteriores para criar o mesmo compilador ou executor nesse ambiente.

# Definir um compilador ou executor
<a name="build-run-debug-define-builder-runner"></a>

Este tópico mostra como você pode definir um compilador ou executor. Antes de definir um compilador ou executor, você deve [criar um compilador ou executor](build-run-debug.md#build-run-debug-create-builder-runner).



Na guia do compilador ou executor exibida, use o JSON para definir o executor ou compilador. Comece com o seguinte código como um modelo.

Para um compilador, comece com esse código.

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

Para um executor, comece com esse código.

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

No código anterior:
+  `cmd`: representa uma lista de cadeias de caracteres separadas por vírgulas AWS Cloud9 para execução como um único comando.

  Ao AWS Cloud9 executar esse comando, cada string na lista será separada por um único espaço. Por exemplo, AWS Cloud9 será executado `"cmd": [ "ls", "$file", "$args"]` como`ls $file $args`, onde AWS Cloud9 `$file` substituirá pelo caminho completo para o arquivo atual e `$args` por quaisquer argumentos inseridos após o nome do arquivo. Para obter mais informações, consulte a lista de variáveis compatíveis posteriormente nesta seção.
+  `script`: representa um script bash (que também pode ser especificado como uma matriz de linhas conforme necessário para legibilidade) executado pelo executor no terminal.
+  `working_dir`: representa o diretório onde o executor será executado.
+  `info`: representa qualquer string de texto que deseje exibir ao usuário no início da execução. Essa string pode conter variáveis, por exemplo`Running $project_path$file_name...`, where AWS Cloud9 será `$project_path` substituída pelo caminho do diretório do arquivo atual e `$file_name` pela parte do nome do arquivo atual. Consulte a lista de variáveis compatíveis posteriormente nesta seção.
+  `env`: representa qualquer matriz de argumentos de linha de comando AWS Cloud9 para uso, por exemplo:

  ```
  "env": {
    "LANG": "en_US.UTF-8",
    "SHLVL": "1"
  }
  ```
+  `selector`: representa qualquer expressão regular que você deseja usar AWS Cloud9 para identificar os nomes dos arquivos que se aplicam a esse executor. Por exemplo, especifique `source.py` para arquivos Python.
+  `debugger`: representa o nome de qualquer depurador disponível que você queira AWS Cloud9 usar que seja compatível com esse executor. Por exemplo, especifique `v8` para o depurador V8.
+  `debugport`: representa o número da porta que você deseja AWS Cloud9 usar durante a depuração. Por exemplo, especifique `15454` para o número da porta a ser usada.

A tabela a seguir mostra as variáveis que podem ser utilizadas.


****  

|  **Variável**  |  **Descrição**  | 
| --- | --- | 
|   `$file_path`   |  O diretório do arquivo atual, por exemplo, `/home/ec2-user/environment` ou `/home/ubuntu/environment`.  | 
|   `$file`   |  O caminho completo para o arquivo atual, por exemplo, `/home/ec2-user/environment/hello.py` ou `/home/ubuntu/environment/hello.py`.  | 
|   `$args`   |  Todos os argumentos inseridos após o nome do arquivo, por exemplo, `"5" "9"`.  | 
|   `$file_name`   |  A parte do nome do arquivo atual, por exemplo, `hello.py`.  | 
|   `$file_extension`   |  A extensão do arquivo atual, por exemplo, `py`.  | 
|   `$file_base_name`   |  O nome do arquivo atual sem a extensão de arquivo, por exemplo, `hello`.  | 
|   `$packages`   |  O caminho completo para a pasta de pacotes.  | 
|   `$project`   |  O caminho completo para a pasta do projeto atual.  | 
|   `$project_path`   |  O diretório do arquivo de projeto atual, por exemplo, `/home/ec2-user/environment/` ou `/home/ubuntu/environment/`.  | 
|   `$project_name`   |  O nome do arquivo de projeto atual sem a extensão de arquivo, por exemplo, `my-demo-environment`.  | 
|   `$project_extension`   |  A extensão do arquivo de projeto atual.  | 
|   `$project_base_name`   |  O nome do arquivo de projeto atual sem a extensão.  | 
|   `$hostname`   |  O nome de host do ambiente, por exemplo, `192.0.2.0`.  | 
|   `$hostname_path`   |  O nome de host do ambiente com o caminho relativo para o arquivo de projeto, por exemplo, `https://192.0.2.0/hello.js`.  | 
|   `$url`   |  O URL completo para acessar o ambiente, por exemplo, `https://192.0.2.0.`.  | 
|   `$port`   |  A porta atribuída ao ambiente, por exemplo, `8080`.  | 
|   `$ip`   |  Os endereços IP para executar um processo no ambiente, por exemplo, `0.0.0.0`.  | 

Como exemplo, o arquivo de compilador chamado `G++.build` define um compilador para GCC que executa o comando ** `g++` ** com a opção `-o` para compilar o arquivo atual (por exemplo, `hello.cpp`) em um módulo de objeto. Em seguida, ele vincula o módulo de objeto em um programa com o mesmo nome que o arquivo atual (por exemplo, `hello`). Aqui o 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"
}
```

Como outro exemplo, o arquivo de executor a seguir chamado `Python.run` define um executor que usa Python para executar o arquivo atual com todos os argumentos fornecidos. Por exemplo, se o arquivo atual se chama `hello.py` e os argumentos `5` e `9` foram fornecidos, o comando equivalente é `python hello.py 5 9`.

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

Finalmente, o arquivo de executor a seguir chamado `Print Run Variables.run` define um executor simplesmente gera o valor de cada variável disponível e, em seguida, é encerrado.

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