

 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.

# Tutoriel Docker pour AWS Cloud9
<a name="sample-docker"></a>

Ce didacticiel explique comment connecter un environnement de développement AWS Cloud9 SSH à un conteneur Docker en cours d'exécution dans une instance Amazon Linux dans Amazon EC2. Cela vous permet d'utiliser l' AWS Cloud9 IDE pour travailler avec du code et des fichiers à l'intérieur d'un conteneur Docker et pour exécuter des commandes sur ce conteneur. Pour plus d'informations sur Docker, consultez [Qu'est-ce que Docker](https://www.docker.com/what-docker) sur le site web de Docker.

Le fait de suivre ce didacticiel et de créer cet exemple peut entraîner des frais sur votre AWS compte. Il peut s'agir de frais pour des services tels qu'Amazon EC2. Pour plus d’informations, consultez [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/).

**Topics**
+ [Conditions préalables](#sample-docker-prereqs)
+ [Étape 1 : Installer et exécuter Docker](#sample-docker-install)
+ [Étape 2 : Créer l'image](#sample-docker-build)
+ [Étape 3 : Exécuter le conteneur](#sample-docker-run)
+ [Étape 4 : Créer l'environnement](#sample-docker-env)
+ [Étape 5 : Exécuter le code](#sample-docker-code)
+ [Étape 6 : Nettoyer](#sample-docker-clean-up)

## Conditions préalables
<a name="sample-docker-prereqs"></a>
+  **Vous devez avoir une instance Amazon EC2 exécutant Amazon Linux ou Ubuntu Server.** Cet exemple suppose que vous disposez déjà d'une instance Amazon EC2 exécutant Amazon Linux ou Ubuntu Server dans votre AWS compte. Pour lancer une instance Amazon EC2, consultez [Lancer une machine virtuelle Linux](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/). Dans la page **Choisir une Amazon Machine Image (AMI)** de l'assistant, sélectionnez une AMI dont le nom d'affichage commence par **Amazon Linux AMI** ou **Ubuntu Server**.
+  **Si l'instance Amazon EC2 s'exécute sur un Amazon VPC, des exigences supplémentaires s'appliquent**. Consultez [Paramètres VPC pour les environnements de développement AWS Cloud9](vpc-settings.md).
+  **L'instance Amazon EC2 doit avoir au moins entre 8 et 16 Go d'espace disque disponible**. Cet exemple utilise les images Docker dont la taille est supérieure à 3 Go et qui peuvent utiliser des incréments de 3 Go ou plus d'espace disque pour créer des images. Si vous essayez d'exécuter cet exemple de code sur un disque de 8 Go d'espace libre ou moins, nous avons constaté que l'image Docker peut ne pas se générer ou que le conteneur Docker peut ne pas s'exécuter. Pour vérifier l'espace disque libre de l'instance, vous pouvez exécuter une commande comme ** `df -h` ** (pour « informations sur le système de fichiers disque dans un format convivial ») sur l'instance. Pour augmenter la taille du disque d'une instance existante, consultez la section [Modification d'un volume](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html) dans le guide de l'*utilisateur Amazon EC2*.

## Étape 1 : Installer et exécuter Docker
<a name="sample-docker-install"></a>

Au cours de cette étape, vérifiez si Docker est installé sur l'instance Amazon EC2 et installez Docker s'il n'est pas encore installé. Une fois que vous avez installé Docker, vous l'exécutez sur l'instance.

1. Connectez-vous à l'instance Amazon EC2 en cours d'exécution à l'aide d'un client SSH tel que l'utilitaire ** `ssh` ** ou PuTTY. Pour ce faire, consultez l'« Étape 3 : Se connecter à l'instance » de la section [Lancer une machine virtuelle Linux](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/).

1. Vérifiez si Docker est installé sur l'instance. Pour ce faire, exécutez la commande ** `docker` ** sur l'instance avec l'option ** `--version`**.

   ```
   docker --version
   ```

   Si Docker est installé, le numéro de version de Docker et le numéro de génération sont affichés. Dans ce cas, passez directement à l'étape 5 ultérieurement dans la procédure.

1. Installez Docker. Pour ce faire, exécutez la commande ** `yum` ** ou ** `apt` ** avec l'action ** `install` **, en spécifiant le paquet ** `docker` ** ou ** `docker.io` ** à installer.

   Pour Amazon Linux :

   ```
   sudo yum install -y docker
   ```

   Pour Ubuntu Server :

   ```
   sudo apt install -y docker.io
   ```

1. Confirmez que Docker est installé. Pour ce faire, exécutez à nouveau la commande ** `docker --version` **. Le numéro de version de Docker et le numéro de génération sont affichés.

1. Exécutez Docker. Pour ce faire, exécutez la commande ** `service` ** avec le service ** `docker` ** et l'action ** `start` ** 

   ```
   sudo service docker start
   ```

1. Confirmez que Docker est en cours d'exécution. Pour ce faire, exécutez la commande ** `docker` ** avec l'action ** `info` **.

   ```
   sudo docker info
   ```

   Si Docker est en cours d'exécution, les informations sur Docker s'affichent.

## Étape 2 : Créer l'image
<a name="sample-docker-build"></a>

Au cours de cette étape, vous utilisez un Dockerfile pour créer une image Docker disponible sur l'instance. Cet exemple utilise une image qui inclut Node.js et un exemple d'application serveur de chat instantanée.

1. Sur l'instance, créez le Dockerfile. Pour ce faire, avec le client SSH toujours connecté à l'instance, dans le répertoire `/tmp` de l'instance, créez un fichier nommé `Dockerfile`. Par exemple, exécutez la commande ** `touch` ** comme suit.

   ```
   sudo touch /tmp/Dockerfile
   ```

1. Ajoutez le contenu suivant au fichier `Dockerfile`.

   ```
   # Build a Docker image based on the Amazon Linux 2 Docker image.
   FROM amazonlinux:2
   
   # install common tools
   RUN yum install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
   RUN yum update -y
   RUN yum install -y sudo bash curl wget git man-db nano vim bash-completion tmux  gcc gcc-c++ make tar
   
   # Enable the Docker container to communicate with AWS Cloud9 by
   # installing SSH.
   RUN yum install -y openssh-server
   
   # Ensure that Node.js is installed.
   RUN yum install -y nodejs
   
   # Create user and enable root access
   RUN useradd --uid 1000 --shell /bin/bash -m --home-dir /home/ubuntu ubuntu && \
       sed -i 's/%wheel\s.*/%wheel ALL=NOPASSWD:ALL/' /etc/sudoers && \
       usermod -a -G wheel ubuntu
   
   # Add the AWS Cloud9 SSH public key to the Docker container.
   # This assumes a file named authorized_keys containing the
   # AWS Cloud9 SSH public key already exists in the same
   # directory as the Dockerfile.
   RUN mkdir -p /home/ubuntu/.ssh
   ADD ./authorized_keys /home/ubuntu/.ssh/authorized_keys
   RUN chown -R ubuntu /home/ubuntu/.ssh /home/ubuntu/.ssh/authorized_keys && \
   chmod 700 /home/ubuntu/.ssh && \
   chmod 600 /home/ubuntu/.ssh/authorized_keys
   
   # Update the password to a random one for the user ubuntu.
   RUN echo "ubuntu:$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)" | chpasswd
   
   # pre-install Cloud9 dependencies
   USER ubuntu
   RUN curl https://d2j6vhu5uywtq3.cloudfront.net/static/c9-install.sh | bash
   
   USER root
   # Start SSH in the Docker container.
   CMD ssh-keygen -A && /usr/sbin/sshd -D
   ```

   Pour ajouter le contenu précédent au fichier `Dockerfile`, vous pouvez utiliser l'utilitaire ** `vi` ** sur l'instance comme suit.

   1. Utilisez le AWS Cloud9 pour ouvrir et modifier le `/tmp/Dockerfile` fichier.

      ```
      sudo vi /tmp/Dockerfile
      ```

   1. Collez le contenu précédent dans le fichier `Dockerfile`. Si vous avez un doute sur la procédure, consultez la documentation du client SSH.

   1. Basculez en mode commande. Pour ce faire, appuyez sur la touche `Esc`. (`-- INSERT --` disparaît de bas de la fenêtre.)

   1. Tapez `:wq` (pour écrire dans le fichier `/tmp/Dockerfile`, enregistrer le fichier et quitter ** `vi` **), puis appuyez sur `Enter`.
**Note**  
Vous pouvez accéder à une liste fréquemment mise à jour d'images Docker à partir de AWS CodeBuild. Pour plus d'informations, consultez les [images Docker fournies CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html) dans le *guide de l'AWS CodeBuild utilisateur*.

1. Sur l'instance, créez un fichier contenant la clé publique AWS Cloud9 SSH à utiliser par le conteneur Docker. Pour ce faire, dans le même répertoire que le fichier `Dockerfile`, créez un fichier nommé `authorized_keys`, par exemple, en exécutant la commande ** `touch` **.

   ```
   sudo touch /tmp/authorized_keys
   ```

1. Ajoutez la clé publique AWS Cloud9 SSH au `authorized_keys` fichier. Pour obtenir la clé publique AWS Cloud9 SSH, procédez comme suit :

   1. Ouvrez la AWS Cloud9 console à l'adresse [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).

   1. Dans la barre de AWS navigation, dans le sélecteur de AWS région, choisissez la AWS région dans laquelle vous souhaitez créer l'environnement de AWS Cloud9 développement plus loin dans cette rubrique.

   1. Si une page de bienvenue s'affiche, pour **Nouvel AWS Cloud9 environnement**, choisissez **Créer un environnement**. Sinon, choisissez **Create environment (Créer un environnement)**.

   1. Dans la page **Nom de l'environnement**, pour le champ **Nom**, tapez un nom pour votre environnement. (Le nom n'est pas important ici. Vous choisirez un autre nom plus tard.)

   1. Choisissez **Étape suivante**.

   1. Pour **Type d'environnement**, choisissez **Se connecter et exécuter dans le serveur distant (SSH))**.

   1. Développez **View public SSH key (Afficher la clé publique SSH**.

   1. Choisissez **Copier la clé vers le presse-papiers)**. (Se trouve entre **Afficher la clé publique SSH)** et **Paramètres avancés**.)

   1. Choisissez **Cancel (Annuler)**.

   1. Collez le contenu du Presse-papiers dans le fichier `authorized_keys`, puis enregistrez le fichier. Par exemple, vous pouvez utiliser l'utilitaire ** `vi` **, comme décrit plus haut dans cette étape.

1. Créez l'image en exécutant la commande ** `docker` ** avec l'action ** `build` ** , en ajoutant la balise `cloud9-image:latest` à l'image et en spécifiant le chemin d'accès au fichier `Dockerfile` à utiliser.

   ```
   sudo docker build -t cloud9-image:latest /tmp
   ```

   En cas de réussite, les deux dernières lignes de la sortie de génération affichent `Successfully built` et `Successfully tagged`.

   Pour confirmer que Docker a correctement créé l'image, exécutez la commande ** `docker` ** avec l'action `image ls`.

   ```
   sudo docker image ls
   ```

   En cas de réussite, la sortie affiche une entrée où le champ `REPOSITORY` a la valeur `cloud9-image` et le champ `TAG` la valeur `latest`.

1. Notez la valeur l'adresse IP publique de l'instance Amazon EC2. Vous en aurez besoin pour l'[Étape 4 : Créer l'environnement](#sample-docker-env). Si vous avez des doutes sur l'adresse IP publique de l'instance, vous pouvez exécuter la commande suivante sur l'instance pour l'obtenir.

   ```
   curl http://169.254.169.254/latest/meta-data/public-ipv4
   ```

## Étape 3 : Exécuter le conteneur
<a name="sample-docker-run"></a>

Au cours de cette étape, vous allez exécuter un conteneur Docker sur l'instance. Ce conteneur est basé sur l'image que vous avez créée à l'étape précédente.

1. Pour exécuter le conteneur Docker, exécutez la commande ** `docker` ** sur l'instance avec l'action ** `run` ** et les options suivantes.

   ```
   sudo docker run -d -it --expose 9090 -p 0.0.0.0:9090:22 --name cloud9 cloud9-image:latest
   ```
   +  `-d` exécute le conteneur en mode détaché, et quitte chaque fois que le processus racine qui est utilisé pour exécuter le conteneur (dans cet exemple, le client SSH) se termine.
   +  `-it` exécute le conteneur avec une pseudo-condition TTY allouée, et conserve STDIN ouvert, même si le conteneur n'est pas attaché.
   +  `--expose` rend le port spécifié (dans cet exemple, port `9090`) disponible depuis le conteneur.
   +  `-p` rend le port spécifié disponible en interne pour l'instance Amazon EC2 sur l'adresse IP et le port spécifiés. Dans cet exemple, le port `9090` sur le conteneur est accessible en interne via le port `22` sur l'instance Amazon EC2.
   +  `--name` est un nom compréhensible pour le conteneur (dans cet exemple, `cloud9`).
   +  `cloud9-image:latest` est le nom compréhensible de l'image créée à utiliser pour exécuter le conteneur.

   Pour confirmer que Docker exécute correctement le conteneur, exécutez la commande ** `docker` ** avec l'action `container ls`.

   ```
   sudo docker container ls
   ```

   En cas de réussite, la sortie affiche une entrée où le champ `IMAGE` a la valeur `cloud9-image:latest` et le champ `NAMES` la valeur `cloud9`.

1. Connectez-vous au conteneur en cours d'exécution. Pour ce faire, exécutez la commande ** `docker` ** avec l'action ** `exec` ** et les options suivantes.

   ```
   sudo docker exec -it cloud9 bash
   ```
   +  `-it` exécute le conteneur avec une pseudo-condition TTY allouée, et conserve STDIN ouvert, même si le conteneur n'est pas attaché.
   +  `cloud9` est le nom compréhensible du conteneur en cours d'exécution.
   +  `bash` démarre le shell standard dans le conteneur en cours d'exécution.

   En cas de réussite, l'invite du terminal est modifiée et affiche le nom de l'utilisateur connecté comme nom du conteneur, ainsi que l'ID du conteneur.
**Note**  
Si vous souhaitez enregistrer le conteneur en cours d'exécution, exécutez la commande ** `exit` **. L'invite du terminal est modifiée à nouveau et affiche le nom de l'utilisateur connecté comme nom de l'instance, ainsi que le DNS privé de l'instance. Le conteneur doit toujours être en cours d'exécution.

1. Pour le répertoire du conteneur en cours d'exécution à partir duquel vous AWS Cloud9 souhaitez démarrer une fois qu'il s'est connecté, définissez ses autorisations d'accès sur **`rwxr-xr-x`**. Cela signifie read-write-execute des autorisations pour le propriétaire, des autorisations de lecture-exécution pour le groupe et des autorisations de lecture-exécution pour les autres. Par exemple, si le chemin d'accès du répertoire est `~`, vous pouvez définir ces autorisations sur le répertoire en exécutant la commande ** `chmod` ** dans le conteneur en cours d'exécution comme suit.

   ```
   sudo chmod u=rwx,g=rx,o=rx ~
   ```

1. Notez le chemin d'accès du répertoire sur le conteneur en cours d'exécution qui contient le fichier binaire Node.js, car vous en aurez besoin pour l'[Étape 4 : Créer l'environnement](#sample-docker-env). Si vous avez des doutes sur le chemin d'accès, exécutez la commande suivante sur le conteneur en cours d'exécution pour l'obtenir.

   ```
   which node
   ```

## Étape 4 : Créer l'environnement
<a name="sample-docker-env"></a>

Au cours de cette étape, vous devez AWS Cloud9 créer un environnement de développement AWS Cloud9 SSH et le connecter au conteneur Docker en cours d'exécution. Après avoir AWS Cloud9 créé l'environnement, il affiche l' AWS Cloud9 IDE afin que vous puissiez commencer à travailler avec les fichiers et le code du conteneur.

Vous créez un environnement de développement AWS Cloud9 SSH avec la AWS Cloud9 console. Vous ne pouvez pas créer un environnement SSH à l'aide de la CLI.

### Conditions préalables
<a name="prerequisites"></a>
+ Assurez-vous que vous avez terminé les étapes de [Con AWS Cloud9 figuration](setting-up.md) dans un premier temps. De cette façon, vous pouvez vous connecter à la console AWS Cloud9 et créer des environnements.
+ Identifiez une instance de cloud computing existante (par exemple, une instance Amazon EC2 dans la vôtre Compte AWS) ou votre propre serveur que vous souhaitez connecter AWS Cloud9 à l'environnement.
+ Vérifiez que l'instance existante ou votre propre serveur respecte toutes les [Configuration requise de l'hôte SSH](ssh-settings.md#ssh-settings-requirements). Les exigences incluent l'installation de versions spécifiques de Python, Node.js et d'autres composants, la définition d'autorisations spécifiques sur le répertoire à partir duquel vous voulez qu' AWS Cloud9 démarre après la connexion, et la configuration des éventuels Amazon Virtual Private Cloud associés.

### Créer l'environnement SSH
<a name="create-the-envsshtitle"></a>

1. Assurez-vous d'avoir suivi les prérequis précédents.

1. Connectez-vous à votre instance existante ou à votre propre serveur à l'aide d'un client SSH, si vous n'y êtes pas déjà connecté. Cela garantit que vous pouvez ajouter la valeur de la clé publique SSH nécessaire à l'instance ou au serveur. Cette opération est détaillée plus loin dans cette procédure.
**Note**  
Pour vous connecter à une instance de AWS Cloud calcul existante, consultez une ou plusieurs des ressources suivantes :  
Pour Amazon EC2, consultez [Connect to your Linux instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) dans le guide de l'utilisateur *Amazon EC2*.
Pour Amazon Lightsail, consultez [Connexion à votre instance Lightsail basée sur Linux/Unix](https://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-connect-to-your-instance-virtual-private-server) dans la *documentation Amazon Lightsail*.
Pour AWS Elastic Beanstalk ce qui est de la [liste et de la connexion aux instances de serveur](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.ec2connect.html), voir le *Guide du AWS Elastic Beanstalk développeur*.
Pour AWS OpsWorks, voir [Utiliser SSH pour se connecter à une instance Linux](https://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-ssh.html) dans le *Guide de l'AWS OpsWorks utilisateur*.
Pour les autres Services AWS, consultez la documentation de ce service spécifique.
Pour vous connecter à votre propre serveur, utilisez SSH. SSH est déjà installé sur les systèmes d'exploitation macOS et Linux. Pour vous connecter à votre serveur en utilisant SSH sous Windows, vous devez installer [PuTTY](https://www.putty.org/).

1. Connectez-vous à la AWS Cloud9 console, à l'adresse [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).

1. Une fois connecté à la AWS Cloud9 console, dans la barre de navigation supérieure, choisissez un dans lequel Région AWS créer l'environnement. Pour obtenir la liste des produits disponibles Régions AWS, consultez [AWS Cloud9](https://docs.aws.amazon.com/general/latest/gr/rande.html#cloud9_region)le *Références générales AWS*.  
![\[Sélecteur de région dans la console AWS Cloud9\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/images/consolas_region_new_UX.png)

1. Si vous créez un environnement de développement pour la première fois, une page d'accueil s'affiche. Dans le panneau **Nouvel AWS Cloud9 environnement**, choisissez **Créer un environnement**.

   Si vous avez déjà créé des environnements de développement, vous pouvez également développer le volet situé à gauche de l'écran. Sélectionnez **Your environments** (Vos environnements), puis sélectionnez **Create environment** (Créer un environnement).

   Dans la page **d'accueil** :  
![\[Cliquez sur le bouton Create environment (Créer un environnement) si la page d'accueil s'affiche\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)

   Ou dans la page **Vos environnements** :  
![\[Cliquez sur le bouton Create environment (Créer un environnement) si la page d'accueil ne s'affiche pas\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/images/console_create_env_new_UX.png)

1. Sur la page **Create environment** (Créer un environnement), saisissez un nom pour votre environnement.

1. Pour **Description**, saisissez des informations concernant votre environnement. Dans le cadre de ce tutoriel, utilisez `This environment is for the AWS Cloud9 tutorial.`

1. Pour **Environment type** (Type d'environnement), sélectionnez **Existing Compute** (Calcul existant) parmi les options suivantes :
   + **Nouvelle instance EC2** — Lance une instance Amazon EC2 AWS Cloud9 qui peut se connecter directement via SSH.
   + **Calcul existant** : lance une instance Amazon EC2 qui ne nécessite aucun port entrant ouvert. AWS Cloud9 se connecte à l'instance via [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html).
     + Si vous sélectionnez l'option **Existing compute** (Calcul existant), une fonction de service et un profil d'instance IAM sont créés pour permettre à Systems Manager d'interagir avec l'instance EC2 en votre nom. Vous pouvez voir les noms des deux éléments dans **Fonction du service et profil d'instance pour l'accès à Systems Manager** plus bas sur l'interface. Pour de plus amples informations, veuillez consulter [Accès aux instances EC2 sans entrée avec AWS Systems Manager](ec2-ssm.md). 
**Avertissement**  
La création d'une instance EC2 pour votre environnement peut entraîner des frais Compte AWS pour Amazon EC2. L'utilisation de Systems Manager pour gérer les connexions à votre instance EC2 n'entraîne aucun coût supplémentaire.
**Avertissement**  
AWS Cloud9 utilise une clé publique SSH pour se connecter en toute sécurité à votre serveur. Pour établir la connexion sécurisée, ajoutez notre clé publique à votre fichier `~/.ssh/authorized_keys` et fournissez vos identifiants de connexion dans les étapes suivantes. Choisissez **Copy key to clipboard** (Copier la clé dans le presse-papiers) pour copier la clé SSH, ou **View public SSH key** (Afficher la clé SSH publique) pour l'afficher.

1. Sur le panneau **Existing compute** (Calcul existant), pour **User** (Utilsiateur), entrez le nom de connexion que vous avez utilisé pour vous connecter à l'instance ou au serveur plus tôt dans cette procédure. Par exemple, pour une instance de calcul AWS Cloud , cela peut être `ec2-user`, `ubuntu` ou `root`. 
**Note**  
Nous vous recommandons d'associer le nom de connexion à des privilèges d'administration ou à un administrateur sur l'instance ou le serveur. Plus précisément, nous recommandons que ce nom de connexion possède l'installation de Node.js sur l'instance ou le serveur. Pour le vérifier, depuis le terminal de votre instance ou serveur, exécutez la commande **`ls -l $(which node)`** (ou **`ls -l $(nvm which node)`** si vous utilisez `nvm`). Cette commande affiche le nom du propriétaire de l'installation Node.js. Il affiche également les autorisations, le nom du groupe et l'emplacement de l'installation.

1. Pour **Host** (Hôte), saisissez l'adresse IP publique (préférée) ou le nom d'hôte de l'instance ou du serveur.

1. Pour **Port**, entrez le port que vous souhaitez utiliser AWS Cloud9 pour essayer de vous connecter à l'instance ou au serveur. Vous pouvez également conserver le port par défaut.

1. Choisissez **Additional details - optional** (Détails supplémentaires - facultatif) pour afficher le chemin de l'environnement, le chemin vers le binaire node.js et les informations sur l'hôte de saut SSH.

1. Dans le **champ Environment path**, entrez le chemin d'accès au répertoire de l'instance ou du serveur AWS Cloud9 à partir duquel vous souhaitez démarrer. Vous l'avez identifié plus tôt dans les conditions préalables à cette procédure. Si vous laissez ce champ vide, AWS Cloud9 utilise le répertoire à partir duquel votre instance ou serveur démarre généralement une fois connecté. Il s'agit généralement d'un répertoire de base ou par défaut.

1. Pour **Path to Node.js binary path** (Chemin d'accès au binaire Node.js), entrez les informations de chemin d'accès pour spécifier le chemin d'accès au binaire Node.js sur l'instance ou le serveur. Pour obtenir le chemin, vous pouvez exécuter la commande **`which node`** (ou ** `nvm which node` ** si vous utilisez `nvm`) sur votre instance ou serveur. Par exemple, le chemin peut être `/usr/bin/node`. Si vous laissez ce champ vide, AWS Cloud9 tente de deviner l'emplacement du fichier binaire Node.js quand il essaie de se connecter.

1. Pour **SSH jump host** (Hôte de saut SSH), entrez les informations sur l'hôte de saut que l'instance ou le serveur utilise. Utilisez le format `USER_NAME@HOSTNAME:PORT_NUMBER` (par exemple, `ec2-user@:ip-192-0-2-0:22`).

   Le serveur de saut doit satisfaire aux exigences suivantes :
   + Il doit être accessible via l'Internet public avec SSH.
   + Il doit autoriser l'accès entrant par n'importe quelle adresse IP sur le port spécifié.
   + La valeur de la clé SSH publique qui a été copiée dans le fichier `~/.ssh/authorized_keys` de l'instance existante ou du serveur existant doit également être copiée dans le fichier `~/.ssh/authorized_keys` du serveur de saut.
   + Netcat doit être installé.

1. Ajoutez jusqu'à 50 identifications en fournissant une **clé** et une **valeur** pour chaque identification. Pour ce faire, sélectionnez **Add new tag** (Ajouter une nouvelle balise). Les balises sont attachées à l' AWS Cloud9 environnement sous forme de balises de ressources et sont propagées aux ressources sous-jacentes suivantes : la CloudFormation pile, l'instance Amazon EC2 et les groupes de sécurité Amazon EC2. Pour en savoir plus sur les balises, consultez la section [Contrôler l'accès à l'aide de balises de AWS ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) dans le *[guide de l'utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/)* et les [informations avancées](tags.md) sur les balises dans ce guide.
**Avertissement**  
Si vous mettez à jour ces balises après les avoir créées, les modifications ne sont pas propagées aux ressources sous-jacentes. Pour plus d'informations, consultez [Propagation des mises à jour des balises vers les ressources sous-jacentes](tags.md#tags-propagate) dans les informations avancées relatives aux [identifications](tags.md).

1. Choisissez **Create** (Créer) pour créer votre environnement, et vous êtes ensuite redirigé vers la page d'accueil. Lorsque le compte est créé avec succès, une barre flash verte apparaît en haut de la AWS Cloud9 console. Vous pouvez sélectionner le nouvel environnement et choisir **Open in Cloud9** (Ouvrir dans Cloud9) pour lancer l'IDE.   
![\[AWS Cloud9 Sélecteur IDE dans la console AWS Cloud9\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/images/cloud9-ide-open.png)

   Si la création du compte échoue, une barre d'éclair rouge apparaît en haut de la console AWS Cloud9 . La création de votre compte peut échouer en raison d'un problème lié à votre navigateur Web, AWS à vos autorisations d'accès, à l'instance ou au réseau associé. Vous trouverez des informations sur les solutions possibles aux problèmes qui peuvent entraîner l'échec du compte dans la section [Résolution des problèmes de AWS Cloud9](troubleshooting.md#troubleshooting-env-loading).

**Note**  
Si votre environnement utilise un proxy pour accéder à Internet, vous devez fournir les détails du proxy AWS Cloud9 afin qu'il puisse installer les dépendances. Pour de plus amples informations, veuillez consulter [Impossible d'installer les dépendances](troubleshooting.md#proxy-failed-dependencies).

## Étape 5 : Exécuter le code
<a name="sample-docker-code"></a>

Au cours de cette étape, vous utilisez l' AWS Cloud9 IDE pour exécuter un exemple d'application dans le conteneur Docker en cours d'exécution.

1. Avec l' AWS Cloud9 IDE affiché pour le conteneur en cours d'exécution, démarrez l'exemple de serveur de chat. Pour ce faire, dans la fenêtre **Environment (Environnement)**, cliquez avec le bouton droit sur l'exemple de fichier `workspace/server.js`, puis choisissez **Run (Exécuter)**.

1. Affichez un aperçu de l'exemple d'application. Pour ce faire, dans la fenêtre **Environment (Environnement)**, ouvrez le fichier `workspace/client/index.html`. Ensuite, dans la barre des menus, choisissez **Tools, Preview, Preview Running Application (Outils, Aperçu, Aperçu de l'application en cours d'exécution)**.

1. Dans l'onglet d'aperçu de l'application, pour **Your Name (Votre nom)**, tapez votre nom. Tapez un message dans le champ **Message**. Puis, choisissez **Send (Envoyer)**. Le serveur de chat instantanée ajoute votre nom et votre message à la liste.

## Étape 6 : Nettoyer
<a name="sample-docker-clean-up"></a>

Au cours de cette étape, vous supprimez l'environnement AWS Cloud9 et supprimez les fichiers de support Docker de l'instance Amazon EC2. En outre, pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez mettre fin à l'instance Amazon EC2 qui exécute Docker.

### Étape 6.1 : Supprimer l'environnement
<a name="step-6-1-delete-the-envtitle"></a>

Pour supprimer l'environnement, consultez [Supprimer un environnement dans AWS Cloud9](delete-environment.md).

### Étape 6.2 : Supprimer les fichiers de AWS Cloud9 support du conteneur
<a name="step-6-2-remove-ac9-support-files-from-the-container"></a>

Une fois l'environnement supprimé, certains fichiers de AWS Cloud9 support restent dans le conteneur. Si vous souhaitez continuer à utiliser le conteneur mais que vous n'avez plus besoin de ces fichiers de support, supprimez le `.c9` dossier du répertoire du conteneur AWS Cloud9 à partir duquel vous avez indiqué de commencer une fois que celui-ci s'est connecté. Par exemple, si le répertoire est `~`, exécutez la commande ** `rm` ** avec l'option ** `-r` ** comme suit.

```
sudo rm -r ~/.c9
```

### Étape 6.3 : Supprimer les fichiers de support Docker de l'instance
<a name="step-6-3-remove-docker-support-files-from-the-instance"></a>

Si vous ne souhaitez pas conserver le conteneur Docker, l'image Docker et Docker sur l'instance Amazon EC2, mais que vous souhaitez conserver l'instance, vous pouvez supprimer ces fichiers de support Docker comme suit.

1. Supprimez le conteneur Docker de l'instance. Pour ce faire, exécutez la commande ** `docker` ** sur l'instance avec les actions d'arrêt ** `stop` ** et ** `rm` **, et le nom complet du conteneur.

   ```
   sudo docker stop cloud9
   sudo docker rm cloud9
   ```

1. Supprimez l'image Docker de l'instance. Pour ce faire, exécutez la commande ** `docker` ** sur l'instance avec l'action ** `image rm`** et la balise de l'image.

   ```
   sudo docker image rm cloud9-image:latest
   ```

1. Supprimez les éventuels fichiers de support Docker toujours existants. Pour ce faire, exécutez la commande ** `docker` ** sur l'instance avec l'action ** `system prune`**.

   ```
   sudo docker system prune -a
   ```

1. Désinstallez Docker. Pour ce faire, exécutez la commande ** `yum` ** sur l'instance avec l'action ** `remove` **, en spécifiant le paquet ** `docker` ** à désinstaller.

   Pour Amazon Linux :

   ```
   sudo yum -y remove docker
   ```

   Pour Ubuntu Server :

   ```
   sudo apt -y remove docker
   ```

   Vous pouvez également supprimer les fichiers `Dockerfile` et `authorized_keys` que vous avez créés précédemment. Par exemple, exécutez la commande ** `rm` ** sur l'instance.

   ```
   sudo rm /tmp/Dockerfile
   sudo rm /tmp/authorized_keys
   ```

### Étape 6.4 : Résilier l'instance
<a name="step-6-4-terminate-the-instance"></a>

Pour mettre fin à l'instance Amazon EC2, consultez la section [Résiliation de votre instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) dans le guide de l'utilisateur *Amazon EC2*.