AWS Cloud9 ist für Neukunden nicht mehr verfügbar. Bestehende Kunden von AWS Cloud9 können den Dienst weiterhin wie gewohnt nutzen. [Weitere Informationen](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Arbeiten mit Buildern, Runnern und Debuggern in der IDE AWS Cloud9
Ein *Builder* weist die AWS Cloud9 Integrierte Entwicklungsumgebung (IDE) an, wie die Dateien eines Projekts erstellt werden. Ein *Runner* weist die AWS Cloud9 IDE an, wie Dateien eines bestimmten Typs ausgeführt werden sollen. Ein Runner kann einen *Debugger* verwenden, um Probleme im Quellcode der Dateien zu finden.
Sie können die AWS Cloud9 IDE verwenden, um Ihren Code auf folgende Weise zu erstellen, auszuführen und zu debuggen:
+ Verwenden Sie einen Builder zum Erstellen Ihrer Projektdateien. Weitere Informationen finden Sie unter [Erstellen der Dateien Ihres Projekts](#build-run-debug-build).
+ Verwenden Sie einen Runner, um Ihren Code auszuführen (und optional zu debuggen). Weitere Informationen finden Sie unter [Integrierte Build-, Run- und Debug-Unterstützung](#build-run-debug-supported) und [Ausführen Ihres Codes](#build-run-debug-run).
+ Ändern Sie einen integrierten Runner so, dass er Ihren Code auf eine andere Art wie ursprünglich definiert ausführt (und optional debuggt). Weitere Informationen finden Sie unter [Ändern eines integrierten Runners](build-run-debug-change-runner.md).
+ Verwenden Sie einen Runner, um Ihren Code mit einer benutzerdefinierten Kombination aus Dateinamen, Befehlszeilenoptionen, Debug-Modus, aktuellem Arbeitsverzeichnis und Umgebungsvariablen auszuführen (und optional zu debuggen). Weitere Informationen finden Sie unter [Erstellen einer Run-Konfiguration](build-run-debug-create-run-config.md).
+ Erstellen Sie Ihren eigenen Builder oder Runner. Weitere Informationen finden Sie unter [Builder oder Runner erstellen](#build-run-debug-create-builder-runner).
## Integrierte Unterstützung für das Erstellen, Ausführen und Debuggen
Die AWS Cloud9 IDE bietet integrierte Unterstützung für das Erstellen, Ausführen und Debuggen von Code für mehrere Sprachen. Eine vollständige Liste finden Sie unter [Sprachunterstützung](language-support.md).
Die integrierte Unterstützung für das Erstellen ist auf der Menüleiste über die Menübefehle **Run** (Ausführen), **Build System** (Build-System) und **Run** (Ausführen), **Build (Entwickeln)** verfügbar. Informationen zum Hinzufügen von Unterstützung für eine Programmiersprache oder ein Tool, die bzw. das nicht aufgeführt ist, finden Sie unter [Einen Builder oder Runner erstellen](#build-run-debug-create-builder-runner).
Integrierte Unterstützung für die Ausführung ist verfügbar über die Schaltfläche **Run** (Ausführen) und über die Menüleiste mit den Menübefehlen **Run** (Ausführen), **Run With** (Ausführen mit) und **Run** (Ausführen), **Run Configurations** (Ausführungskonfigurationen). Informationen zum Hinzufügen von Unterstützung für eine Programmiersprache oder ein Tool, die bzw. das nicht aufgeführt ist, finden Sie unter [Einen Builder oder Runner erstellen](#build-run-debug-create-builder-runner) und [Eine Run-Konfiguration erstellen](build-run-debug-create-run-config.md).
Integrierte Unterstützung für das Debuggen ist über das **Debugger**-Fenster verfügbar. Zum Anzeigen des **Debugger**-Fensters wählen Sie die Schaltfläche **Debugger** aus. Wenn die Schaltfläche **Debugger** nicht angezeigt wird, wählen Sie **Window (Fenster)**, **Debugger** auf der Menüleiste aus.
## Erstellen Ihrer Projektdateien
1. Öffnen Sie eine Datei, die dem Code entspricht, den Sie erstellen möchten.
1. Klicken Sie auf der Menüleiste auf **Run, Build System (Ausführen, Build-System)** und wählen Sie dann den Namen des zu verwendenden Builders, wenn dieser nicht bereits ausgewählt ist. Wenn der Builder, den Sie verwenden möchten, nicht aufgeführt ist, beenden Sie dieses Verfahren, führen Sie die Schritte in [Create a Builder or Runner](#build-run-debug-create-builder-runner) aus und kehren Sie dann zu diesem Verfahren zurück.
1. Wählen Sie **Run, Build (Ausführen, Erstellen)**.
## Ausführen Ihres Codes
1. Öffnen Sie eine Datei, die dem Code entspricht, den Sie ausführen möchten, wenn die Datei nicht bereits geöffnet und ausgewählt ist.
1. Wählen Sie auf der Menüleiste eine der folgenden Optionen aus:
+ Zum Ausführen des Codes mit dem am besten passenden integrierten Runner wählen Sie **Run (Ausführen), Run (Ausführen)** aus. Wenn AWS Cloud9 kein Befehl gefunden werden kann, ist dieser Befehl deaktiviert.
+ Um den Code mit der AWS Cloud9 zuletzt verwendeten Ausführungskonfiguration auszuführen, wählen Sie **Run, Run Last**.
+ Zum Ausführen des Codes mit einem bestimmten Runner wählen Sie **Run (Ausführen), Run With (Ausführen mit)** und dann den Namen des Runner. Wenn der Runner, den Sie verwenden möchten, nicht aufgeführt ist, beenden Sie dieses Verfahren, führen Sie die Schritte in [Einen Builder oder Runner erstellen](#build-run-debug-create-builder-runner) aus und kehren Sie dann zu diesem Verfahren zurück.
+ Zum Ausführen des Codes mit einem bestimmten Runner mit einer benutzerdefinierten Kombination aus Dateinamen, Befehlszeilenoptionen, Debug-Modus, aktuellem Arbeitsverzeichnis und Umgebungsvariablen wählen Sie **Run (Ausführen), Run Configurations (Ausführungskonfigurationen)** und dann den Namen der Run-Konfiguration aus. Wählen Sie in der angezeigten Konfigurationsregisterkarte **Runner: Auto** aus, klicken Sie auf den Runner, den Sie verwenden möchten und wählen Sie dann **Run (Ausführen)** aus. Wenn der Runner, den Sie verwenden möchten, nicht aufgeführt ist, beenden Sie dieses Verfahren, führen Sie die Schritte in [Einen Builder oder Runner erstellen](#build-run-debug-create-builder-runner) aus und kehren Sie dann zu diesem Verfahren zurück.
## Debuggen Ihres Codes
1. Wählen Sie auf der Registerkarte der Run-Konfiguration für Ihren Code **Run in Debug Mode (Im Debug-Modus ausführen)** aus. Das Bug-Symbol wird nun grün auf weißem Hintergrund. Weitere Informationen finden Sie unter [Ihren Code ausführen](#build-run-debug-run) und [Erstellen einer Run-Konfiguration](build-run-debug-create-run-config.md).
1. Legen Sie alle Haltepunkte in Ihrem Code fest, an denen während der Ausführung angehalten werden soll:
1. Öffnen Sie jede Datei, in der Sie einen Haltepunkt festlegen möchten.
1. An jeder Punkt in einer Datei, an dem Sie einen Haltepunkt festlegen möchten, wählen Sie den leeren Bereich im Bundsteg links neben der Zeilennummer. Ein roter Kreis wird angezeigt.
Wenn Sie einen Haltepunkt entfernen möchten, wählen Sie den vorhandenen Haltepunkt im Bundsteg.
Wenn Sie einen Haltepunkt deaktivieren, anstatt entfernen möchten, deaktivieren Sie im Fenster **, Debugger** unter **Breakpoints (Haltepunkte)** das Feld, das dem Haltepunkt entspricht, den Sie deaktivieren möchten. Wenn Sie den Haltepunkt erneut aktivieren möchten, aktivieren Sie das Kontrollkästchen, das Sie abgewählt haben.
Um alle Haltepunkte auf einmal zu deaktivieren, wählen Sie im Fenster **Debugger** **Deactivate All Breakpoints (Alle Haltepunkte deaktivieren)** aus. Um alle Haltepunkte erneut zu aktivieren, wählen Sie **Activate All Breakpoints (Alle Haltepunkte aktivieren)** aus.
Wenn das Fenster **Debugger** nicht angezeigt wird, wählen Sie die Schaltfläche **Debugger** aus. Wenn die Schaltfläche **Debugger** nicht angezeigt wird, wählen Sie **Window (Fenster)**, **Debugger** auf der Menüleiste aus.
1. Legen Sie alle Überwachungsausdrücke fest, für die Sie den Wert an dem Punkt erhalten möchten, an dem eine Ausführung angehalten wird:
1. Klicken Sie im Fenster **Debugger** unter **Watch Expressions (Überwachungsausdrücke)** auf die Option **Type an expression here (Einen Ausdruck hier eingeben)**.
1. Geben Sie den Ausdruck ein, die Sie überwachen möchten, und drücken Sie anschließend `Enter`.
Zum Ändern eines vorhandenen Überwachungsausdrucks klicken Sie mit der rechten Maustaste auf den Überwachungsausdruck und wählen dann **Edit Watch Expression (Überwachungsausdruck bearbeiten)** aus. Geben Sie die Änderung ein und drücken Sie anschließend `Enter`.
Zum Entfernen eines vorhandenen Überwachungsausdrucks klicken Sie mit der rechten Maustaste auf den Überwachungsausdruck und wählen dann **Remove Watch Expression (Überwachungsausdruck entfernen)** aus.
1. Führen Sie Ihren Code wie in [Ihren Code ausführen](#build-run-debug-run) beschrieben aus.
Wenn eine Ausführung angehalten wird, können Sie auch mit dem Mauszeiger auf einem beliebigen angezeigten Codeteil anhalten (z. B. einer Variable), um alle verfügbaren Informationen darüber in einer QuickInfo anzuzeigen.
# Einen integrierten Runner ändern
Dieser Schritt zeigt, wie Sie einen integrierten Runner so ändern können, dass er Ihren Code anders ausführt (und optional debuggt), als er ursprünglich definiert wurde.
1. Klicken Sie auf der Menüleiste auf **Run (Ausführen), Run With (Ausführen mit)** und wählen Sie dann den integrierten Runner, den Sie ändern möchten.
1. Hindern Sie den Runner am Versuch, Ihren Code auszuführen, indem Sie **Stop (Stoppen)** auf der Registerkarte mit der Run-Konfiguration auswählen, die angezeigt wird.
1. Wählen Sie **Runner: My Runner** aus, wobei **My Runner** der Name des Runners ist, den Sie ändern möchten, und wählen Sie dann **Runner bearbeiten**.
1. Ändern Sie auf der angezeigten Registerkarte **My Runner.run** die aktuelle Definition des Runners. Weitere Informationen finden Sie unter [Einen Builder oder Runner definieren](build-run-debug-define-builder-runner.md).
1. Wählen Sie **File (Datei), Save As (Speichern unter)** aus. Speichern Sie die Datei mit demselben Namen (**My Runner.run**) in dem `my-environment/.c9/runners` Verzeichnis, in dem sich der Name Ihrer `my-environment` Entwicklungsumgebung befindet. AWS Cloud9
**Anmerkung**
Alle Änderungen, die Sie an einem integrierten Runner vornehmen, gelten nur für die Umgebung, in der Sie diese Änderungen gemacht haben. Um Ihre Änderungen auf eine separate Umgebung anzuwenden, öffnen Sie die andere Umgebung und führen Sie dann die oben beschriebenen Schritten aus, um diese gleichen Änderungen in diesem integrierten Runner zu öffnen, zu bearbeiten und zu speichern.
# Erstellen einer Run-Konfiguration
Dieser Schritt zeigt, wie Sie mit einem Runner Ihren Code mit einer benutzerdefinierten Kombination aus Dateiname, Befehlszeilenoptionen, Debug-Modus, aktuellem Arbeitsverzeichnis und Umgebungsvariablen ausführen (und optional debuggen) können.
Wählen Sie auf der Menüleiste **Run (Ausführen), Run Configurations (Ausführungskonfigurationen), New Run Configuration (Neue Run-Konfiguration)** aus. Führen Sie auf der angezeigten Registerkarte der Run-Konfiguration die folgenden Schritte aus:
1. Geben Sie im Feld neben **Run (Ausführen)** und **Neustart** den Namen ein, der auf dem Menü **Run (Ausführen), Run Configurations (Ausführungskonfigurationen)** für diese Run-Konfiguration angezeigt wird.
1. Geben Sie im Feld **Command (Befehl)** beliebige benutzerdefinierte Befehlszeilenoptionen ein, die Sie verwenden möchten.
1. Damit diese Run-Konfiguration die vordefinierten Debugging-Einstellungen des Runners verwendet, wählen Sie **Run in Debug Mode (Im Debug-Modus ausführen)** aus. Das Bug-Symbol wird grün auf weißem Hintergrund angezeigt.
1. Damit diese Run-Konfiguration ein bestimmtes Arbeitsverzeichnis verwendet, wählen Sie **CWD**, das zu verwendende Verzeichnis und dann **Select (Auswählen)** aus.
1. Damit diese Konfiguration bestimmte Umgebungsvariablen verwendet, wählen Sie **ENV** und geben Sie dann den Namen und den Wert der einzelnen Umgebungsvariablen ein.
Zur Verwendung dieser Run-Konfiguration öffnen Sie die Datei, die dem Code entspricht, den Sie ausführen möchten. Wählen Sie auf der Menüleiste **Run (Ausführen), Run Configurations (Ausführungskonfigurationen)** klicken Sie anschließend auf den Namen dieser Run-Konfiguration. Wählen Sie in der angezeigten Konfigurationsregisterkarte **Runner: Auto** aus, klicken Sie auf den Runner, den Sie verwenden möchten und wählen Sie dann **Run (Ausführen)** aus.
**Anmerkung**
Alle Ausführungskonfigurationen, die Sie erstellen, gelten nur für die Umgebung, in der Sie diese Run-Konfiguration erstellt haben. Um diese Run-Konfiguration zu einer separaten Umgebung hinzuzufügen, öffnen Sie die andere Umgebung und folgen Sie dann den oben beschriebenen Schritten, um dieselbe Run-Konfiguration in dieser Umgebung zu erstellen.
## Einen Builder oder Runner erstellen
Dieser Schritt zeigt, wie du deinen eigenen Builder oder Runner erstellen kannst.
1. Um einen Builder zu erstellen, wählen Sie auf der Menüleiste **Run (Ausführen), Build System (Build-System), New Build System (Neues Build-System)**. Um einen Runner zu erstellen, wählen Sie auf der Menüleiste **Run (Ausführen), Run With (Ausführen mit), New Runner (Neuer Runner)** aus.
1. Definieren Sie auf der Builder-Registerkarte (mit der Bezeichnung **My Builder.build**) oder auf der Runner-Registerkarte (mit der Bezeichnung **My Runner.run**), die angezeigt wird, den Builder oder Runner. Weitere Informationen finden Sie unter [Einen Builder oder Runner definieren](build-run-debug-define-builder-runner.md).
1. Nachdem Sie den Builder oder Runner definiert haben, wählen Sie **File (Datei), Save As (Speichern unter)**. Speichern Sie die Datei für einen Builder mit der `.build`-Erweiterung im `my-environment/.c9/builders`-Verzeichnis, wobei `my-environment` der Name Ihrer Umgebung ist. Speichern Sie die Datei für einen Runner mit der `.run`-Dateierweiterung im `my-environment/.c9/runners`-Verzeichnis, wobei `my-environment` der Name Ihrer Umgebung ist. Der Dateiname, den Sie angeben, ist der Name, der im Menü **Run (Ausführen), Build System (Build-System)** (für einen Builder) oder im Menü **Run (Ausführen), Run With (Ausführen mit)** (für einen Runner) angezeigt wird. Wenn Sie keinen anderen Dateinamen angeben, ist der Anzeigename daher standardmäßig **My Builder** (für einen Builder) oder **My Runner** (für einen Runner).
Informationen zur Verwendung dieses Builders oder Runners finden Sie unter [Erstellen Ihrer Projektdateien](#build-run-debug-build) oder [Ihren Code ausführen](#build-run-debug-run).
**Anmerkung**
Alle Builder oder Runner, die Sie erstellen, gelten nur für die Umgebung, in der Sie diesen Builder oder Runner erstellt haben. Um diesen Builder oder Runner zu einer separaten Umgebung hinzuzufügen, öffnen Sie die andere Umgebung und folgen Sie dann den oben beschriebenen Schritten, um denselben Builder oder Runner in dieser Umgebung zu erstellen.
# Einen Builder oder Runner definieren
In diesem Thema wird gezeigt, wie Sie einen Builder oder Runner definieren können. Bevor Sie einen Builder oder Runner definieren, stellen Sie sicher, dass Sie [einen Builder oder Runner erstellt](build-run-debug.md#build-run-debug-create-builder-runner) haben.
Verwenden Sie auf der angezeigten Builder- oder Runner-Registerkarte JSON, um den Runner oder Builder zu definieren. Beginnen Sie mit dem folgenden Code als Vorlage.
Für einen Builder beginnen Sie mit diesem Code.
```
{
"cmd": [],
"info": "",
"env": {},
"selector": ""
}
```
Für einen Runner beginnen Sie mit diesem Code.
```
{
"cmd": [],
"script": "",
"working_dir": "",
"info": "",
"env": {},
"selector": "",
"debugger": "",
"debugport": ""
}
```
Im vorhergehenden Code:
+ `cmd`: Stellt eine durch Kommas getrennte Liste von Zeichenketten dar AWS Cloud9 , die als ein einziger Befehl ausgeführt werden sollen.
Wenn dieser Befehl AWS Cloud9 ausgeführt wird, wird jede Zeichenfolge in der Liste durch ein einzelnes Leerzeichen getrennt. AWS Cloud9 Wird beispielsweise `"cmd": [ "ls", "$file", "$args"]` als ausgeführt`ls $file $args`, wobei durch den vollständigen Pfad zur aktuellen Datei und `$args` durch alle Argumente ersetzt AWS Cloud9 `$file` wird, die nach dem Dateinamen eingegeben werden. Weitere Informationen finden Sie in der Liste der unterstützten Variablen weiter unten in diesem Abschnitt.
+ `script`: Stellt ein Bash-Skript dar (das auch als ein Array von Zeilen angegeben werden darf, je nach Bedarf für Lesbarkeit), das der Runner im Terminal ausführt.
+ `working_dir`: Stellt das Verzeichnis dar, von dem der Runner ausgeführt wird.
+ `info`: Stellt eine beliebige Text-Zeichenfolge dar, die Sie dem Benutzer zu Beginn der Ausführung anzeigen möchten. Diese Zeichenfolge kann Variablen enthalten, z. B. `Running $project_path$file_name...` where AWS Cloud9 wird `$project_path` durch den Verzeichnispfad der aktuellen Datei und `$file_name` durch den Namensteil der aktuellen Datei ersetzt. Eine Liste der unterstützten Variablen finden Sie weiter unten in diesem Abschnitt.
+ `env`: Stellt ein beliebiges Array von Befehlszeilenargumenten dar, AWS Cloud9 die verwendet werden können, zum Beispiel:
```
"env": {
"LANG": "en_US.UTF-8",
"SHLVL": "1"
}
```
+ `selector`: Stellt einen beliebigen regulären Ausdruck dar, AWS Cloud9 den Sie verwenden möchten, um die Dateinamen zu identifizieren, die für diesen Runner gelten. Sie können beispielweise `source.py` für Python-Dateien angeben.
+ `debugger`: Stellt den Namen jedes verfügbaren Debuggers dar, den Sie verwenden AWS Cloud9 möchten und der mit diesem Runner kompatibel ist. Sie können beispielweise `v8` für den V8-Dubugger angeben.
+ `debugport`: Stellt die Portnummer dar, die Sie beim Debuggen verwenden AWS Cloud9 möchten. Sie können beispielweise `15454` als zu verwendende Portnummer verwenden.
Die folgende Tabelle zeigt die Variablen an, die Sie verwenden können.
****
| **Variable** | **Beschreibung** |
| --- | --- |
| `$file_path` | Das Verzeichnis der aktuellen Datei, z. B. `/home/ec2-user/environment` oder `/home/ubuntu/environment`. |
| `$file` | Der vollständige Pfad zur aktuellen Datei, z. B. `/home/ec2-user/environment/hello.py` oder `/home/ubuntu/environment/hello.py`. |
| `$args` | Alle Argumente, die nach dem Dateinamen eingegeben wurden, z. B. `"5" "9"`. |
| `$file_name` | Der Namensteil des aktuellen Datei, z. B. `hello.py`. |
| `$file_extension` | Die Erweiterung der aktuellen Datei, z. B. `py`. |
| `$file_base_name` | Der Name der aktuellen Datei ohne die Dateierweiterung, z. B. `hello`. |
| `$packages` | Der vollständige Pfad zum Paketordner. |
| `$project` | Der vollständige Pfad zum aktuellen Projektordner. |
| `$project_path` | Das Verzeichnis der aktuellen Projektdatei, z. B. `/home/ec2-user/environment/` oder `/home/ubuntu/environment/`. |
| `$project_name` | Der Name der aktuellen Projektdatei ohne die Dateierweiterung, z. B. `my-demo-environment`. |
| `$project_extension` | Die Erweiterung der aktuellen Projektdatei. |
| `$project_base_name` | Der Name der aktuellen Projektdatei ohne die Erweiterung. |
| `$hostname` | Der Hostname der Umgebung, z. B. `192.0.2.0`. |
| `$hostname_path` | Der Hostname der Umgebung mit dem relativen Pfad zur Projektdatei, z. B. `https://192.0.2.0/hello.js`. |
| `$url` | Die vollständige URL für den Zugriff auf die Umgebung, z. B. `https://192.0.2.0.`. |
| `$port` | Der Port, der der Umgebung zugewiesen ist, z. B. `8080`. |
| `$ip` | Die IP-Adresse zum Ausführen eines Prozesses gegen die Umgebung, z. B. `0.0.0.0`. |
Beispielsweise definiert die folgende Builder-Datei mit dem Namen `G++.build` einen Builder für GCC, der den Befehl ** `g++` ** mit der Option `-o` zum Kompilieren der aktuellen Datei (z. B. `hello.cpp`) in ein Objektmodul ausführt. Anschließend wird das Objektmodul in ein Programm mit demselben Namen wie die aktuelle Datei (z. B. `hello`) verlinkt. Hier ist der entsprechende Befehl `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"
}
```
In diesem weiteren Beispiel definiert die folgende Runner-Datei mit der Bezeichnung `Python.run` einen Runner, der Python verwendet, um die aktuelle Datei mit allen Argumenten auszuführen, die angegeben wurden. Wenn beispielsweise die aktuelle Datei `hello.py` und die Argumente `5` und `9` angegeben wurden, lautet der entsprechende Befehl `python hello.py 5 9`.
```
{
"cmd": [ "python", "$file_name", "$args" ],
"info": "Running $file_name...",
"selector": "source.py"
}
```
Schließlich definiert die folgende Runner-Datei mit dem Namen `Print Run Variables.run` einen Runner, der einfach den Wert jeder verfügbaren Variable ausgibt und dann stoppt.
```
{
"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"
}
```