AWS Cloud9 n'est plus disponible pour les nouveaux clients. Les clients existants d’ AWS Cloud9 peuvent continuer à l’utiliser normalement. [En savoir plus](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Travailler avec des constructeurs, des exécuteurs et des débogueurs dans l'IDE AWS Cloud9
Un *générateur* indique à l'environnement de développement AWS Cloud9 intégré (IDE) comment créer les fichiers d'un projet. Un *lanceur* indique à l' AWS Cloud9 IDE comment exécuter des fichiers d'un type spécifique. Un exécuteur peut utiliser un *débogueur* pour rechercher des problèmes dans le code source des fichiers.
Vous pouvez utiliser l' AWS Cloud9 IDE pour créer, exécuter et déboguer votre code de la manière suivante :
+ Utilisez un générateur pour générer les fichiers de votre projet. Pour plus d'informations, consultez la section [Création des fichiers de votre projet](#build-run-debug-build).
+ Utilisez un exécuteur pour exécuter (et éventuellement déboguer) votre code. Pour plus d'informations, consultez les sections [Support intégré à la création, à l'exécution et au débogage](#build-run-debug-supported) et [Exécutez votre code](#build-run-debug-run).
+ Modifiez un exécuteur intégré pour exécuter (et éventuellement déboguer) votre code différemment de sa définition d'origine. Pour plus d'informations, voir [Modifier un coureur intégré](build-run-debug-change-runner.md).
+ Utilisez un exécuteur pour exécuter (et éventuellement déboguer) votre code avec une combinaison personnalisée de nom de fichier, d'options de ligne de commande, de mode débogage, de répertoire de travail actuel et de variables d'environnement. Pour plus d'informations, consultez la section [Créer une configuration d'exécution](build-run-debug-create-run-config.md).
+ Créez votre propre générateur ou exécuteur. Pour plus d'informations, voir [Création d'un générateur ou d'un coureur](#build-run-debug-create-builder-runner).
## Prise en charge intégrée de la génération, de l'exécution et du débogage
L' AWS Cloud9 IDE fournit un support intégré pour la création, l'exécution et le débogage de code pour plusieurs langues. Pour obtenir la liste complète, consultez [Prise en charge des langages](language-support.md).
La prise en charge intégrée de la génération est disponible dans la barre de menus avec les commandes de menu **Exécuter**, **Système de génération** et **Exécuter**, **Générer**. Pour ajouter la prise en charge d'un outil ou d'un langage de programmation qui n'est pas répertorié, consultez [Création d'un générateur ou d'un exécuteur](#build-run-debug-create-builder-runner).
La prise en charge intégrée de l'exécution est disponible avec le bouton **Exécuter** et dans la barre de menus avec les commandes de menu **Exécuter**, **Exécuter avec** et **Exécuter**, **Configuration d'exécution**. Pour ajouter la prise en charge d'un outil ou d'un langage de programmation qui n'est pas répertorié, consultez [Création d'un générateur ou d'un exécuteur](#build-run-debug-create-builder-runner) et [Création d'une configuration d'exécution](build-run-debug-create-run-config.md).
La prise en charge intégrée du débogage est disponible dans la fenêtre **Débogueur**. Pour afficher la fenêtre **Débogueur**, cliquez sur le bouton **Débogueur**. Si le bouton **Débogueur** ne s'affiche pas, choisissez **Fenêtre**, **Débogueur** dans la barre de menus.
## Génération des fichiers de votre projet
1. Ouvrez un fichier correspondant au code à générer.
1. Dans la barre de menus, choisissez **Exécuter, Système de génération**, puis le nom du générateur à utiliser, s'il n'est pas déjà choisi. Si le générateur que vous souhaitez utiliser n'est pas répertorié, arrêtez cette procédure, suivez les étapes de la section [Création d'un générateur ou d'un exécuteur](#build-run-debug-create-builder-runner), puis revenez à cette procédure.
1. Choisissez **Exécuter, Générer**.
## Exécution de votre code
1. Ouvrez un fichier correspondant au code à exécuter, si le fichier n'est pas déjà ouvert et sélectionné.
1. Dans la barre de menus, choisissez l'un des éléments suivants :
+ Pour exécuter le code avec l'exécuteur intégré le plus adapté possible, choisissez **Exécuter, Exécuter**. Si vous AWS Cloud9 n'en trouvez pas, cette commande est désactivée.
+ Pour exécuter le code avec la AWS Cloud9 dernière configuration d'exécution utilisée, choisissez **Run, Run Last**.
+ Pour exécuter le code avec un exécuteur spécifique, choisissez **Exécuter, Exécuter avec**, puis choisissez le nom de l'exécuteur. Si l'exécuteur que vous souhaitez utiliser n'est pas répertorié, arrêtez cette procédure, suivez les étapes de la section [Création d'un générateur ou d'un exécuteur](#build-run-debug-create-builder-runner), puis revenez à cette procédure.
+ Pour exécuter le code avec un exécuteur spécifique et avec une combinaison personnalisée de nom de fichier, d'options de ligne de commande, de mode débogage, de répertoire de travail actuel et de variables d'environnement, choisissez **Exécuter, Configuration de l'exécution**, puis choisissez le nom de la configuration d'exécution. Dans l'onglet de configuration d'exécution qui s'affiche, choisissez **Exécuteur : Auto**, l'exécuteur à utiliser, puis **Exécuter**. Si l'exécuteur que vous souhaitez utiliser n'est pas répertorié, arrêtez cette procédure, suivez les étapes de la section [Création d'un générateur ou d'un exécuteur](#build-run-debug-create-builder-runner), puis revenez à cette procédure.
## Débogage de votre code
1. Dans l'onglet de configuration de l'exécution de votre code, choisissez **Exécuter en mode de débogage**. L'icône de bogue devient verte sur un fond blanc. Pour plus d'informations, consultez [Exécution de votre code](#build-run-debug-run) et [Création d'une configuration d'exécution](build-run-debug-create-run-config.md).
1. Dans votre code, définissez des points d'arrêt dans le code pour indiquer où vous souhaitez suspendre l'exécution, comme suit :
1. Ouvrez chaque fichier dans lequel vous voulez définir un point d'arrêt.
1. À chaque emplacement dans un fichier où vous souhaitez définir un point d'arrêt, choisissez la zone vide dans la marge à gauche du numéro de ligne. Un cercle rouge s'affiche.
Pour supprimer un point d'arrêt, choisissez le point d'arrêt dans la marge.
Pour désactiver un point d'arrêt au lieu de le supprimer, dans la fenêtre **Débogueur**, dans **Points d'arrêt**, désélectionnez la case à cocher correspondant à désactiver. Pour réactiver le point d'arrêt, cochez sa case.
Pour désactiver tous les points d'arrêt, dans la fenêtre **Débogueur**, choisissez **Désactiver tous les points d'arrêt**. Pour réactiver tous les points d'arrêt, choisissez **Activer tous les points d'arrêt**.
Si la fenêtre **Débogueur** n'est pas visible, choisissez le bouton **Débogueur**. Si le bouton **Débogueur** n'est pas visible, dans la barre de menus, choisissez **Fenêtre**, **Débogueur**.
1. Définissez les expressions à évaluer pour lesquelles vous souhaitez obtenir la valeur au point où une exécution s'arrête, comme suit :
1. Dans la fenêtre **Débogueur**, dans **Expression à évaluer**, choisissez **Saisir une expression ici**.
1. Saisissez l'expression à évaluer, puis appuyez sur `Enter`.
Pour modifier une expression à évaluer, cliquez dessus avec le bouton droit de la souris, puis choisissez **Modifier l'expression à évaluer**. Saisissez la modification, puis appuyez sur `Enter`.
Pour supprimer une expression à évaluer existante, cliquez dessus avec le bouton droit de la souris, puis choisissez **Retirer l'expression à évaluer**.
1. Exécutez votre code comme décrit dans [Exécution de votre code](#build-run-debug-run).
Lorsqu'une exécution est suspendue, vous pouvez également suspendre le pointeur sur n'importe quelle partie de code affichée (par exemple, une variable) pour afficher toutes les informations disponibles la concernant dans une infobulle.
# Modification d'un exécuteur intégré
Cette étape montre comment vous pouvez modifier un Runner intégré pour exécuter (et éventuellement, pour déboguer) votre code d'une manière différente de la façon dont il a été défini à l'origine.
1. Dans la barre de menus, choisissez **Exécuter, Exécuter avec**, puis l'exécuteur intégré à modifier.
1. Pour que l'exécuteur ne tente pas d'exécuter votre code, choisissez **Arrêter** dans l'onglet de configuration d'exécution qui s'affiche.
1. Choisissez **Exécuteur : mon exécuteur**, où **Mon exécuteur** est le nom de l'exécuteur à modifier, puis choisissez **Modifier l'exécuteur**.
1. Sous l'onglet **Mon Runner.run** qui s'affiche, modifiez la définition actuelle de l'exécuteur. Consultez [Définition d'générateur ou d'un exécuteur](build-run-debug-define-builder-runner.md).
1. Choisissez **Fichier, Enregistrer sous)**. Enregistrez le fichier portant le même nom (**My Runner.run**) dans le `my-environment/.c9/runners` répertoire, où se `my-environment` trouve le nom de votre AWS Cloud9 environnement de développement.
**Note**
Toutes les modifications que vous apportez à un exécuteur intégré s'appliquent uniquement à l'environnement dans lequel vous effectuez ces modifications. Pour appliquer vos modifications à un autre environnement, ouvrez cet environnement, puis suivez les étapes précédentes pour ouvrir, modifier et enregistrer ces mêmes modifications dans cet exécuteur intégré.
# Création d'une configuration d'exécution
Cette étape montre comment exécuter (et éventuellement, déboguer) votre code à l'aide d'une combinaison personnalisée de nom de fichier, d'options de ligne de commande, de mode de débogage, de répertoire de travail actuel et de variables d'environnement.
Dans la barre de menus, choisissez **Exécuter, Configuration d'exécution, Nouvelle configuration de l'exécution**. Dans l'onglet de configuration d'exécution qui s'affiche, effectuez les opérations suivantes :
1. Dans la zone en regard de **Exécuter** et **Redémarrer**, saisissez le nom qui s'affiche dans le menu **Exécuter, Configurations d'exécution** pour cette configuration d'exécution.
1. Dans la zone **Commande**, saisissez les options de ligne de commande personnalisées que vous souhaitez utiliser.
1. Pour que cette configuration d'exécution utilise les paramètres de débogage prédéfinis de l'exécuteur, choisissez **Exécuter en mode de débogage**. L'icône de bogue devient verte sur un fond blanc.
1. Pour que cette configuration d'exécution utilise un répertoire de travail spécifique, choisissez **CWD**, le répertoire à utiliser, puis **Séelctionner**.
1. Pour que cette configuration d'exécution utilise des variables d'environnement spécifiques, choisissez **ENV**, puis saisissez le nom et la valeur de chaque variable d'environnement.
Pour utiliser cette configuration d'exécution, ouvrez le fichier qui correspond au code à exécuter. Choisissez **Exécuter, Configuration d'exécution** dans la barre de menus, puis le nom de la configuration d'exécution. Dans l'onglet de configuration d'exécution qui s'affiche, choisissez **Exécuteur : Auto**, l'exécuteur à utiliser, puis **Exécuter**.
**Note**
Toute configuration d'exécution que vous créez s'applique uniquement à l'environnement dans lequel vous avez créé la configuration d'exécution. Pour ajouter cette configuration d'exécution à un environnement séparé, ouvrez l'autre environnement, puis suivez les étapes précédentes pour créer la même configuration d'exécution dans cet environnement.
## Création d'un générateur ou d'un exécuteur
Cette étape montre comment créer votre propre constructeur ou coureur.
1. Pour créer un générateur, choisissez **Exécuter, Système de génération, Nouveau système de génération** dans la barre de menus. Pour créer un exécuteur, choisissez **Exécuter, Exécuter avec, Nouvel exécuteur** dans la barre de menus.
1. Dans l'onglet du générateur (appelé **Mon Builder.build**) ou l'onglet de l'exécuteur (appelé **Mon Runner.run**) qui s'affiche, définissez le générateur ou l'exécuteur. Consultez [Définition d'un générateur ou d'un exécuteur](build-run-debug-define-builder-runner.md).
1. Après avoir défini le générateur ou l'exécuteur, choisissez **Fichier, Enregistrer sous**. Pour un générateur, enregistrez le fichier avec l'extension `.build` dans le répertoire `my-environment/.c9/builders`, où `my-environment` est le nom de votre environnement. Pour un exécuteur, enregistrez le fichier avec l'extension de fichier `.run` dans le répertoire `my-environment/.c9/runners`, où `my-environment` est le nom de votre environnement. Le nom de fichier que vous spécifiez est le nom qui s'affiche dans le menu **Exécuter, Système de génération** (pour un générateur) ou le menu **Exécuter, Exécuter avec** (pour un exécuteur). Par conséquent, sauf si vous spécifiez un nom de fichier différent, le nom d'affichage par défaut est **Mon générateur** (pour un générateur) ou **Mon exécuteur** (pour un exécuteur).
Pour utiliser ce générateur ou cet exécuteur, consultez [Génération des fichiers de votre projet](#build-run-debug-build) ou [Exécution de votre code](#build-run-debug-run).
**Note**
Un générateur ou un exécuteur que vous créez s'applique uniquement à l'environnement que vous avez créé dans ce générateur ou cet exécuteur. Pour ajouter ce générateur ou exécuteur à un autre environnement, ouvrez cet environnement, puis suivez les étapes précédentes pour créer le même générateur ou exécuteur dans cet environnement.
# Définition d'un générateur ou d'un exécuteur
Cette rubrique explique comment définir un constructeur ou un coureur. Avant de définir un constructeur ou un coureur, assurez-vous d'avoir [créé un constructeur ou un coureur](build-run-debug.md#build-run-debug-create-builder-runner).
Sur l'onglet de générateur ou d'exécuteur qui s'affiche, utilisez JSON pour définir le générateur ou l'exécuteur. Commencez par utiliser le code suivant en tant que modèle.
Pour un générateur, commencez avec ce code.
```
{
"cmd": [],
"info": "",
"env": {},
"selector": ""
}
```
Pour un exécuteur, commencez avec ce code.
```
{
"cmd": [],
"script": "",
"working_dir": "",
"info": "",
"env": {},
"selector": "",
"debugger": "",
"debugport": ""
}
```
Dans le code précédent :
+ `cmd`: représente une liste de chaînes séparées par des virgules AWS Cloud9 à exécuter en tant que commande unique.
Lors de l' AWS Cloud9 exécution de cette commande, chaque chaîne de la liste sera séparée par un seul espace. Par exemple, AWS Cloud9 sera exécuté `"cmd": [ "ls", "$file", "$args"]` en tant que`ls $file $args`, where AWS Cloud9 remplacera `$file` par le chemin complet du fichier actuel et `$args` par tous les arguments entrés après le nom du fichier. Pour plus d'informations, consultez la liste des variables prises en charge plus loin dans cette section.
+ `script` : représente un script bash (qui peut être également spécifié en tant que tableau de lignes selon les besoins de lisibilité) que l'exécuteur exécute dans le terminal.
+ `working_dir` : représente le répertoire à partir duquel l'exécuteur s'exécute.
+ `info` : représente n'importe quelle chaîne de texte que vous souhaitez afficher à l'utilisateur au début de l'exécution. Cette chaîne peut contenir des variables, par exemple`Running $project_path$file_name...`, where AWS Cloud9 sera `$project_path` remplacé par le chemin du répertoire du fichier actuel et `$file_name` par le nom du fichier en cours. Consultez la liste des variables prises en charge plus loin dans cette section.
+ `env`: représente n'importe quel tableau d'arguments de ligne de commande AWS Cloud9 à utiliser, par exemple :
```
"env": {
"LANG": "en_US.UTF-8",
"SHLVL": "1"
}
```
+ `selector`: représente toute expression régulière que vous souhaitez utiliser AWS Cloud9 pour identifier les noms de fichiers qui s'appliquent à ce lanceur. Par exemple, vous pouvez spécifier `source.py` pour les fichiers Python.
+ `debugger`: représente le nom de tout débogueur disponible que vous AWS Cloud9 souhaitez utiliser et qui est compatible avec ce lanceur. Par exemple, vous pouvez spécifier `v8` pour le débogueur V8.
+ `debugport`: représente le numéro de port que vous souhaitez AWS Cloud9 utiliser lors du débogage. Par exemple, vous pouvez spécifier `15454` pour le numéro de port à utiliser.
Le tableau suivant répertorie les variables que vous pouvez utiliser.
****
| **Variable** | **Description** |
| --- | --- |
| `$file_path` | Répertoire du fichier actuel, par exemple, `/home/ec2-user/environment` ou `/home/ubuntu/environment`. |
| `$file` | Chemin complet du fichier actuel, par exemple, `/home/ec2-user/environment/hello.py` ou `/home/ubuntu/environment/hello.py`. |
| `$args` | Tous les arguments saisis après le nom de fichier, par exemple, `"5" "9"`. |
| `$file_name` | Partie nom du fichier actuel, par exemple, `hello.py`. |
| `$file_extension` | Extension du fichier actuel, par exemple, `py`. |
| `$file_base_name` | Nom du fichier actuel sans l'extension de fichier, par exemple, `hello`. |
| `$packages` | Chemin complet du dossier de packages. |
| `$project` | Chemin complet du dossier de projet actuel. |
| `$project_path` | Répertoire du fichier de projet actuel, par exemple, `/home/ec2-user/environment/` ou `/home/ubuntu/environment/`. |
| `$project_name` | Nom de fichier du projet actuel sans l'extension de fichier, par exemple, `my-demo-environment`. |
| `$project_extension` | Extension de fichier du projet actuel. |
| `$project_base_name` | Nom de fichier du projet actuel sans l'extension. |
| `$hostname` | Nom d'hôte de l'environnement, par exemple, `192.0.2.0`. |
| `$hostname_path` | Nom d'hôte de l'environnement avec le chemin relatif du fichier du projet, par exemple, `https://192.0.2.0/hello.js`. |
| `$url` | URL complète pour accéder à l'environnement, par exemple, `https://192.0.2.0.`. |
| `$port` | Port affecté à l'environnement, par exemple, `8080`. |
| `$ip` | Adresse IP pour exécuter un processus sur l'environnement, par exemple, `0.0.0.0`. |
Par exemple, le fichier de générateur suivant appelé `G++.build` définit un générateur pour GCC qui exécute la commande ** `g++` ** avec l'option `-o` pour compiler le fichier actuel (par exemple, `hello.cpp`) dans un module d'objet. Ensuite, il associe le module d'objet dans un programme portant le même nom que le fichier actuel (par exemple, `hello`). Ici, la commande équivalente est `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"
}
```
Autre exemple : le fichier d'exécuteur suivant appelé `Python.run` définit un exécuteur qui utilise Python pour exécuter le fichier actuel avec tous les arguments qui ont été fournis. Par exemple, si le fichier actuel s'appelle `hello.py` et que les arguments `5` et `9` ont été fournis, la commande équivalente est `python hello.py 5 9`.
```
{
"cmd": [ "python", "$file_name", "$args" ],
"info": "Running $file_name...",
"selector": "source.py"
}
```
Enfin, le fichier d'exécuteur suivant appelé `Print Run Variables.run` définit un exécuteur qui produit simplement la valeur de chaque variable disponible, puis s'arrête.
```
{
"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"
}
```