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.
# Tutoriels pour AWS Cloud9
Vous êtes nouveau AWS Cloud9 ? Découvrez l'IDE dans [Mise en route : tutoriels de base](tutorials-basic.md).
Testez ces didacticiels et ces exemples de code pour améliorer vos connaissances et votre confiance AWS Cloud9 en utilisant différents langages et AWS services de programmation.
**Topics**
+ [AWS CLI et tutoriel aws-shell](sample-aws-cli.md)
+ [AWS CodeCommit tutoriel](sample-codecommit.md)
+ [Tutoriel Amazon DynamoDB](sample-dynamodb.md)
+ [AWS CDK tutoriel](sample-cdk.md)
+ [Tutoriel LAMP](sample-lamp.md)
+ [WordPress didacticiel](sample-wordpress.md)
+ [Tutoriel Java](sample-java.md)
+ [Tutoriel C\$1\$1](sample-cplusplus.md)
+ [Tutoriel Python](sample-python.md)
+ [Tutoriel .NET](sample-dotnetcore.md)
+ [Tutoriel Node.js](sample-nodejs.md)
+ [Tutoriel PHP](sample-php.md)
+ [Ruby](tutorial-ruby.md)
+ [Tutoriel Go](sample-go.md)
+ [TypeScript didacticiel](sample-typescript.md)
+ [Tutoriel Docker](sample-docker.md)
+ [Didacticiels connexes](#samples-additonal)
# AWS CLI et tutoriel aws-shell pour AWS Cloud9
Le didacticiel suivant vous permet de configurer le AWS Command Line Interface (AWS CLI), le aws-shell ou les deux dans un environnement de AWS Cloud9 développement. Le AWS CLI et l'aws-shell sont des outils unifiés qui fournissent une interface cohérente pour interagir avec toutes les parties de. AWS Vous pouvez utiliser le AWS CLI au lieu de AWS Management Console pour exécuter rapidement des commandes avec lesquelles interagir AWS, et certaines de ces commandes peuvent être exécutées avec le AWS CLI ou à l'aide du AWS CloudShell.
Pour plus d'informations à ce sujet AWS CLI, consultez le [guide de AWS Command Line Interface l'utilisateur](https://docs.aws.amazon.com/cli/latest/userguide/). Pour l'aws-shell, consultez les ressources suivantes :
+ [aws-shell](https://github.com/awslabs/aws-shell) sur le site GitHub
+ [aws-shell](https://pypi.python.org/pypi/aws-shell) sur le site web pip
Pour une liste des commandes que vous pouvez exécuter AWS CLI pour interagir avec AWS, consultez la [référence des AWS CLI commandes](https://docs.aws.amazon.com/cli/latest/reference/). Vous pouvez utiliser les mêmes commandes avec AWS CloudShell, sauf que vous démarrez des commandes sans le `aws` préfixe.
La création de cet échantillon peut entraîner des frais sur votre AWS compte. Il peut s'agir de frais pour des services tels qu'Amazon EC2 et Amazon S3. Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Conditions préalables](#sample-aws-cli-prereqs)
+ [Étape 1 : installez l' AWS CLI aws-shell ou les deux dans votre environnement](#sample-aws-cli-install)
+ [Étape 2 : Configurer la gestion des informations d'identification dans votre environnement](#sample-aws-cli-creds)
+ [Étape 3 : Exécuter des commandes de base avec le AWS CLI ou l'aws-shell dans votre environnement](#sample-aws-cli-run)
+ [Étape 4 : nettoyer](#sample-aws-cli-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : installez l' AWS CLI aws-shell ou les deux dans votre environnement
Au cours de cette étape, vous utilisez l' AWS Cloud9 IDE pour installer l' AWS CLI aws-shell ou les deux dans votre environnement afin de pouvoir exécuter des commandes avec lesquelles interagir. AWS
Si vous utilisez un environnement de développement AWS Cloud9 EC2 et que vous souhaitez uniquement utiliser le AWS CLI, vous pouvez passer à[Étape 3 : Exécuter des commandes de base avec le AWS CLI ou l'aws-shell dans votre environnement](#sample-aws-cli-run). Cela est dû au fait qu' AWS CLI il est déjà installé dans un environnement EC2 et qu'un ensemble d'informations d'identification d' AWS accès est déjà configuré dans l'environnement. Pour de plus amples informations, veuillez consulter [AWS informations d'identification temporaires gérées](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Si vous n'utilisez pas d'environnement EC2, procédez comme suit pour installer la AWS CLI :
1. Votre environnement étant ouvert, dans l'IDE, vérifiez s'il AWS CLI est déjà installé. Dans le terminal, exécutez la commande ** `aws --version` **. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window** (Fenêtre), **New Terminal** (Nouveau terminal).) Si le AWS CLI est installé, le numéro de version est affiché, avec des informations telles que les numéros de version de Python et le numéro de version du système d'exploitation de votre instance Amazon EC2 ou de votre propre serveur. Si le AWS CLI est installé, passez directement à[Étape 2 : Configurer la gestion des informations d'identification dans votre environnement](#sample-aws-cli-creds).
1. Pour l'installer AWS CLI, reportez-vous à la section [Installation du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) dans le *guide de AWS Command Line Interface l'utilisateur*. Par exemple, pour un environnement EC2 exécutant Amazon Linux, exécutez les trois commandes ci-dessous, l'une après l'autre, dans le terminal pour installer la AWS CLI.
```
sudo yum -y update # Install the latest system updates.
sudo yum -y install aws-cli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
Pour un environnement EC2 exécutant Ubuntu Server, exécutez à la place les trois commandes suivantes dans le terminal, l'une après l'autre, afin d'installer la AWS CLI.
```
sudo apt update # Install the latest system updates.
sudo apt install -y awscli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
Si vous voulez installer l'aws-shell, procédez comme suit :
1. Votre environnement étant ouvert, vérifiez si l'aws-shell est déjà installé dans l'IDE. Dans le terminal, exécutez la commande ** `aws-shell` **. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window** (Fenêtre), **New Terminal** (Nouveau terminal).) Si l'aws-shell est installé, l'invite `aws>` s'affiche. Si l'aws-shell est installé, passez directement à [Étape 2 : Configurer la gestion des informations d'identification dans votre environnement](#sample-aws-cli-creds).
1. Pour installer l'aws-shell, vous utilisez pip. Pour utiliser pip, vous devez avoir installé Python.
Pour vérifier si Python est déjà installé (et pour l'installer si nécessaire), suivez les instructions fournies dans la section [Étape 1 : Installer Python](sample-python.md#sample-python-install) de l'*exemple Python*, puis revenez à cette rubrique.
Pour vérifier si pip est déjà installé, dans le terminal, exécutez la commande ** `pip --version`**. Si pip est installé, le numéro de version est affiché. Si pip n'est pas installé, installez-le en exécutez les trois commandes suivantes dans le terminal, l'une après l'autre.
```
wget https://bootstrap.pypa.io/get-pip.py # Get the pip install file.
sudo python get-pip.py # Install pip. (You might need to run 'sudo python2 get-pip.py' or 'sudo python3 get-pip.py' instead, depending on how Python is installed.)
rm get-pip.py # Delete the pip install file, as it is no longer needed.
```
1. Pour utiliser pip afin d'installer l'aws-shell, exécutez la commande suivante.
```
sudo pip install aws-shell
```
## Étape 2 : Configurer la gestion des informations d'identification dans votre environnement
Chaque fois que vous utilisez le shell AWS CLI ou l'aws-shell pour appeler un AWS service, vous devez fournir un ensemble d'informations d'identification avec l'appel. Ces informations d'identification déterminent si le AWS CLI ou l'aws-shell dispose des autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue.
Si vous utilisez un environnement de développement AWS Cloud9 EC2, vous pouvez passer directement à[Étape 3 : Exécuter des commandes de base avec le AWS CLI ou l'aws-shell dans votre environnement](#sample-aws-cli-run). En effet, les informations d'identification sont déjà configurées dans un environnement EC2. Pour de plus amples informations, veuillez consulter [AWS informations d'identification temporaires gérées](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Si vous n'utilisez pas d'environnement EC2, vous devez stocker manuellement vos informations d'identification dans l'environnement. Pour ce faire, suivez les instructions de la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique.
## Étape 3 : Exécuter des commandes de base avec le AWS CLI ou l'aws-shell dans votre environnement
Au cours de cette étape, vous utilisez le shell AWS CLI ou aws-shell de votre environnement pour créer un compartiment dans Amazon S3, répertorier vos compartiments disponibles, puis supprimer le compartiment.
1. Si vous souhaitez utiliser l'aws-shell mais que vous n'avez l'avez pas encore démarré, procédez au démarrage en exécutant la commande `aws-shell`. L'invite `aws>` s'affiche.
1. Créez un compartiment. Exécutez la **`aws s3 mb`**commande avec la **`s3 mb`**commande AWS CLI ou avec l'aws-shell, en fournissant le nom du bucket à créer. Dans cet exemple, nous utilisons un bucket nommé`cloud9-123456789012-bucket`, où se `123456789012` trouve votre identifiant de AWS compte. Si vous utilisez un autre nom, remplacez-le tout au long de cette étape.
```
aws s3 mb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 mb s3://cloud9-123456789012-bucket # For the aws-shell.
```
**Note**
Les noms des compartiments doivent être uniques pour l'ensemble de votre AWS compte AWS, et pas uniquement pour celui-ci. Pour avoir un nom de compartiment unique, utilisez le nom de compartiment suggéré précédemment. Si vous recevez un message contenant l'erreur `BucketAlreadyExists`, réexécutez la commande avec un autre nom de compartiment.
1. Répertoriez vos compartiments disponibles. Exécutez la **`aws s3 ls`**commande avec AWS CLI ou la **`s3 ls`**commande avec l'aws-shell. La liste de vos compartiments disponibles s'affiche.
1. Supprimez le compartiment. Exécutez la **`aws s3 rb`**commande avec AWS CLI ou la **`s3 rb`**commande avec l'aws-shell, en fournissant le nom du bucket à supprimer.
```
aws s3 rb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 rb s3://cloud9-123456789012-bucket # For the aws-shell.
```
Pour confirmer si le bucket a été supprimé, réexécutez la **`aws s3 ls`**commande avec le AWS CLI ou réexécutez la **`s3 ls`**commande avec l'aws-shell. Le nom du compartiment qui a été supprimé ne doit plus apparaître dans la liste.
**Note**
Si vous souhaitez continuer à utiliser le compartiment, vous n'avez pas besoin de le supprimer. Pour plus d'informations, veuillez consulter [Ajouter un objet à un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*. Voir aussi [Commandes S3](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html.html) dans la *AWS CLI Référence des commandes*. (N'oubliez pas que si vous ne supprimez pas le compartiment, cela peut entraîner des frais permanents sur votre AWS compte.)
Pour continuer à expérimenter avec le AWS CLI, consultez la section [Travailler avec Amazon Web Services](https://docs.aws.amazon.com/cli/latest/userguide/chap-working-with-services.html) dans le *guide de l'AWS Command Line Interface utilisateur* ainsi que dans le manuel de [référence des AWS CLI commandes](https://docs.aws.amazon.com/cli/latest/reference/). Pour continuer à tester l'aws-shell, consultez la [Référence de commande de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/), en gardant à l'esprit que vous devez démarrer les commandes sans le préfixe `aws`.
## Étape 4 : nettoyer
Si vous utilisez l'aws-shell, vous pouvez cesser de l'utiliser en exécutant la commande** `.exit` ** ou ** `.quit` **.
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, veuillez consulter [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# AWS CodeCommit tutoriel pour AWS Cloud9
Vous pouvez utiliser le AWS CodeCommit didacticiel pour configurer un environnement de AWS Cloud9 développement dans lequel interagir avec un dépôt de code distant CodeCommit. CodeCommit est un service de contrôle du code source que vous pouvez utiliser pour stocker et gérer de manière privée Git des référentiels dans le AWS Cloud. Pour plus d'informations CodeCommit, consultez le [guide de AWS CodeCommit l'utilisateur](https://docs.aws.amazon.com/codecommit/latest/userguide/).
Le fait de suivre ce didacticiel et de créer cet exemple peut entraîner des frais pour votre Compte AWS. Cela inclut les frais éventuels pour des services tels qu'Amazon EC2 et. CodeCommit Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification AWS CodeCommit](https://aws.amazon.com/codecommit/pricing/).
+ [Conditions préalables](#sample-codecommit-prereqs)
+ [Étape 1 : Configurer votre groupe IAM avec les autorisations d'accès requises](#sample-codecommit-permissions)
+ [Étape 2 : créer un dépôt dans AWS CodeCommit](#sample-codecommit-create-repo)
+ [Étape 3 : Connecter votre environnement au référentiel distant](#sample-codecommit-connect-repo)
+ [Étape 4 : Cloner le référentiel distant dans votre environnement](#sample-codecommit-clone-repo)
+ [Étape 5 : Ajouter les fichiers dans le référentiel](#sample-codecommit-add-files)
+ [Étape 6 : Nnettoyer](#sample-codecommit-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Configurer votre groupe IAM avec les autorisations d'accès requises
Supposons que vos AWS informations d'identification soient associées à un utilisateur administrateur de votre Compte AWS compte et que vous souhaitiez utiliser cet utilisateur pour travailler avec. CodeCommit Ensuite, passez à l'[étape 2 : créer un référentiel dans AWS CodeCommit](#sample-codecommit-create-repo).
Vous pouvez effectuer cette étape à l'aide de la [AWS Management Console](#sample-codecommit-permissions-console) ou de [l'interface de ligne de commande AWS (AWS CLI)](#sample-codecommit-permissions-cli).
### Configurer votre groupe IAM avec les autorisations d'accès requises à l'aide de la console
1. Connectez-vous au AWS Management Console, si ce n'est pas déjà fait.
Pour cette étape, nous vous recommandons de vous connecter à l'aide des informations d'identification d'un utilisateur administrateur de votre Compte AWS. Si vous ne pouvez pas le faire, contactez l'administrateur de votre Compte AWS .
1. Ouvrez la console IAM. Pour ce faire, choisissez **Services** dans la barre de navigation de la console. Choisissez ensuite **IAM**.
1. Choisissez **Groupes**.
1. Choisissez le nom du groupe.
1. Dans l'onglet **Autorisations**, pour **Stratégies gérées**, choisissez **Attacher la stratégie**.
1. Dans la liste des noms de stratégie, activez l'une des cases suivantes :
+ Sélectionnez **AWSCodeCommitPowerUser**pour accéder à toutes les fonctionnalités CodeCommit et aux ressources liées au référentiel. Toutefois, cela ne vous permet pas de supprimer des CodeCommit référentiels ou de créer ou de supprimer des ressources liées aux référentiels dans d'autres sites, Services AWS tels qu'Amazon Events. CloudWatch
+ Sélectionnez **AWSCodeCommitFullAccess**pour un contrôle total sur CodeCommit les référentiels et les ressources associées dans le Compte AWS. Cela inclut la possibilité de supprimer des référentiels.
Si vous ne voyez pas l'un de ces noms de politique dans la liste, saisissez les noms des politiques dans la zone **Filter** (Filtre) pour les afficher.
1. Choisissez **Attach Policy** (Attacher une politique).
Pour consulter la liste des autorisations d'accès que ces politiques AWS gérées accordent à un groupe, consultez la section [Politiques AWS gérées (prédéfinies) AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) dans le *guide de AWS CodeCommit l'utilisateur*.
Passez à l'[étape 2 : créer un référentiel dans AWS CodeCommit](#sample-codecommit-create-repo).
### Configurez votre groupe IAM avec les autorisations d'accès requises à l'aide du AWS CLI
Exécutez la `attach-group-policy` commande IAM en spécifiant le nom du groupe et le nom de ressource Amazon (ARN) de la politique AWS gérée qui décrit les autorisations d'accès requises. La syntaxe est la suivante.
```
aws iam attach-group-policy --group-name MyGroup --policy-arn POLICY_ARN
```
Dans la commande précédente, remplacez `MyGroup` par le nom du groupe. Remplacez `POLICY_ARN` par l'ARN de la politique AWS gérée :
+ `arn:aws:iam::aws:policy/AWSCodeCommitPowerUser`pour accéder à toutes les fonctionnalités CodeCommit et aux ressources liées au référentiel. Toutefois, il ne vous permet pas de supprimer des CodeCommit référentiels ou de créer ou de supprimer des ressources liées aux référentiels dans d'autres sites, Services AWS tels qu'Amazon Events. CloudWatch
+ `arn:aws:iam::aws:policy/AWSCodeCommitFullAccess`pour un contrôle total des CodeCommit référentiels et des ressources associées dans le Compte AWS. Cela inclut la possibilité de supprimer des référentiels.
Pour consulter la liste des autorisations d'accès que ces politiques AWS gérées accordent à un groupe, consultez la section [Politiques AWS gérées (prédéfinies) AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) dans le *guide de AWS CodeCommit l'utilisateur*.
## Étape 2 : créer un dépôt dans CodeCommit
Dans cette étape, vous créez un référentiel de code distant à CodeCommit l'aide de la CodeCommit console.
Si vous possédez déjà un CodeCommit référentiel, passez à l'[étape 3 : Connecter votre environnement au référentiel distant](#sample-codecommit-connect-repo).
Vous pouvez effectuer cette étape à l'aide de la [AWS Management Console](#sample-codecommit-create-repo-console) ou de [l'interface de ligne de commande AWS (AWS CLI)](#sample-codecommit-create-repo-cli).
### Création d'un référentiel à CodeCommit l'aide de la console
1. Supposons que vous soyez connecté au en AWS Management Console tant qu'utilisateur administrateur à l'étape précédente et que vous ne souhaitiez pas utiliser l'utilisateur administrateur pour créer le référentiel. Ensuite, déconnectez-vous du AWS Management Console.
1. Ouvrez la CodeCommit console dans [https://console.aws.amazon.com/codecommit](https://console.aws.amazon.com/codecommit).
1. Dans la barre de navigation de la console, utilisez le sélecteur de région pour choisir la Région AWS dans laquelle vous souhaitez créer le référentiel (par exemple **USA Est (Ohio)**).
1. Si une page de bienvenue s'affiche, choisissez **Mise en route**. Sinon, choisissez **Créer un référentiel**.
1. Sur la page **Create repository** (Créer un référentiel), pour **Repository name** (Nom du référentiel), saisissez un nom pour votre nouveau référentiel (par exemple, `MyDemoCloud9Repo`). Si vous choisissez un autre nom, remplacez-le dans l'ensemble de cet exemple.
1. (Facultatif) Pour **Description**, saisissez des informations relatives au référentiel. Par exemple, vous pouvez saisir : `This is a demonstration repository for the AWS Cloud9 sample.`
1. Choisissez **Créer un référentiel**. Un volet **Connectez-vous à votre référentiel** s'affiche. Choisissez **Fermer**, car vous allez vous connecter à votre référentiel d'une autre manière, plus loin dans cette rubrique.
Passez directement à [Étape 3 : Connecter votre environnement au référentiel distant](#sample-codecommit-connect-repo).
### Créez un référentiel à CodeCommit l'aide du AWS CLI
Exécutez la commande AWS CodeCommit `create-repository`. Spécifiez le nom du référentiel, une description facultative et le nom dans lequel Région AWS créer le référentiel.
```
aws codecommit create-repository --repository-name MyDemoCloud9Repo --repository-description "This is a demonstration repository for the AWS Cloud9 sample." --region us-east-2
```
Dans la commande précédente, remplacez `us-east-2` par l'ID de la Région AWS dans laquelle créer le référentiel. Pour obtenir la liste des régions prises [AWS CodeCommit](https://docs.aws.amazon.com/general/latest/gr/rande.html#codecommit_region)en charge, consultez le *Référence générale d'Amazon Web Services*.
Si vous choisissez d'utiliser un autre nom de référentiel, remplacez-le dans l'ensemble de cet exemple.
## Étape 3 : Connecter votre environnement au référentiel distant
Au cours de cette étape, vous utilisez l' AWS Cloud9 IDE pour vous connecter au CodeCommit référentiel que vous avez créé ou identifié à l'étape précédente.
**Note**
Si vous préférez utiliser Git via une interface visuelle, vous pouvez cloner le référentiel distant. Vous pouvez ensuite ajouter des fichiers à l'aide de la fonctionnalité de [panneau Git](source-control-gitpanel.md) disponible dans l'IDE.
Exécutez l'un des jeux de procédures suivants, selon votre type d'environnement de développement AWS Cloud9 .
****
| **Type d'environnement** | **Suivez ces procédures** |
| --- | --- |
| Environnement EC2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/sample-codecommit.html) |
| Environnement SSH | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/sample-codecommit.html) |
## Étape 4 : Cloner le référentiel distant dans votre environnement
Au cours de cette étape, vous utilisez l' AWS Cloud9 IDE pour cloner le référentiel distant CodeCommit dans votre environnement.
Pour cloner le référentiel, exécutez la commande **`git clone`**. Remplacez `CLONE_URL` par l'URL du clone du référentiel.
```
git clone CLONE_URL
```
Pour un environnement EC2, vous fournissez une URL de clone HTTPS qui commence par `https://`. Pour un environnement SSH, vous fournissez une URL de clone SSH qui démarre par `ssh://`.
Pour obtenir l'URL complète du clone du référentiel, voir [Utiliser la AWS CodeCommit console pour afficher les détails du référentiel](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-view-repository-details.html#how-to-view-repository-details-console) dans le *guide de AWS CodeCommit l'utilisateur*.
Si votre référentiel ne contient aucun fichier, un message d'avertissement s'affiche, tel que `You appear to have cloned an empty repository.`, ce qui est attendu. Vous vous en occuperez plus tard.
## Étape 5 : Ajouter les fichiers dans le référentiel
Dans cette étape, vous créez trois fichiers simples dans le référentiel cloné, dans votre environnement AWS Cloud9 . Vous ajoutez ensuite les fichiers à la zone de stockage Git de votre référentiel cloné. Enfin, vous validez les fichiers préparés et vous transférez le commit vers votre dépôt distant CodeCommit.
Si le référentiel cloné contient déjà des fichiers, vous avez terminé et vous pouvez ignorer la suite de cet exemple.
**Pour ajouter des fichiers dans le référentiel**
1. Créez un nouveau fichier. Dans la barre de menus, choisissez **File (Fichier)**, **New File (Nouveau fichier)**.
1. Entrez le contenu suivant dans le fichier, puis choisissez **Fichier**, **Enregistrer** pour enregistrer le fichier `bird.txt` dans le `MyDemoCloud9Repo` répertoire de votre AWS Cloud9 environnement.
```
bird.txt
--------
Birds are a group of endothermic vertebrates, characterized by feathers,
toothless beaked jaws, the laying of hard-shelled eggs, a high metabolic
rate, a four-chambered heart, and a lightweight but strong skeleton.
```
**Note**
Pour confirmer que vous enregistrez ce fichier dans le répertoire approprié, dans la boîte de dialogue **Save As** (Enregistrer sous), choisissez le dossier `MyDemoCloud9Repo`. Assurez-vous ensuite **Folder** (Dossier) affiche `/MyDemoCloud9Repo`.
1. Créez deux autres fichiers, nommés `insect.txt` et `reptile.txt`, avec le contenu suivant. Supprimez les fichiers dans le répertoire `MyDemoCloud9Repo`.
```
insect.txt
----------
Insects are a class of invertebrates within the arthropod phylum that
have a chitinous exoskeleton, a three-part body (head, thorax, and abdomen),
three pairs of jointed legs, compound eyes, and one pair of antennae.
```
```
reptile.txt
-----------
Reptiles are tetrapod (four-limbed vertebrate) animals in the class
Reptilia, comprising today's turtles, crocodilians, snakes,
amphisbaenians, lizards, tuatara, and their extinct relatives.
```
1. Dans le terminal, exécutez la commande **`cd`** pour passer au répertoire `MyDemoCloud9Repo`.
```
cd MyDemoCloud9Repo
```
1. Vérifiez que les fichiers ont été enregistrés correctement dans le répertoire `MyDemoCloud9Repo` en exécutant la commande **`git status`**. Les trois fichiers seront répertoriés en tant que fichiers non suivis.
```
Untracked files:
(use "git add ..." to include in what will be committed)
bird.txt
insect.txt
reptile.txt
```
1. Ajoutez les fichiers dans la zone intermédiaire Git en exécutant la commande **`git add`**.
```
git add --all
```
1. Confirmez que les fichiers ont bien été ajoutés dans la zone intermédiaire Git en réexécutant la commande **`git status`**. Les trois fichiers sont désormais répertoriés en tant que modifications à valider.
```
Changes to be committed:
(use "git rm --cached ..." to unstage)
new file: bird.txt
new file: insect.txt
new file: reptile.txt
```
1. Validez les fichiers intermédiaires en exécutant la commande **`git commit`**.
```
git commit -m "Added information about birds, insects, and reptiles."
```
1. Transférez le commit vers votre dépôt distant en CodeCommit exécutant la **`git push`**commande.
```
git push -u origin master
```
1. Confirmez que les fichiers ont été correctement envoyés (push). Ouvrez la CodeCommit console, si ce n'est pas déjà fait, dans [https://console.aws.amazon.com/codecommit.](https://console.aws.amazon.com/codecommit)
1. Dans la barre de navigation supérieure, près du bord droit, choisissez l' Région AWS endroit où vous avez créé le référentiel (par exemple, **USA East (Ohio)**).
1. Sur la page **Tableau de bord**, choisissez **MyDemoCloud9Repo**. Les trois fichiers sont affichés.
Pour continuer à expérimenter avec votre CodeCommit dépôt, voir [Parcourir le contenu de votre référentiel](https://docs.aws.amazon.com/codecommit/latest/userguide/getting-started-cc.html#getting-started-cc-browse) dans le *guide de l'AWS CodeCommit utilisateur*.
Si vous êtes nouveau Git et que vous ne voulez pas gâcher votre CodeCommit dépôt, testez un exemple de Git référentiel sur le Git site Web [Try](https://try.github.io/).
## Étape 6 : Nettoyer
Pour éviter que des frais ne vous soient facturés une Compte AWS fois que vous aurez fini d'utiliser cet exemple, supprimez le CodeCommit référentiel. Pour obtenir des instructions, voir [Supprimer un AWS CodeCommit référentiel](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html) dans le *guide de AWS CodeCommit l'utilisateur*.
Assurez-vous également de supprimer l'environnement. Pour obtenir des instructions, consultez [Suppression d'un environnement](delete-environment.md).
# Tutoriel Amazon DynamoDB pour AWS Cloud9
Ce didacticiel vous permet de configurer un environnement de AWS Cloud9 développement compatible avec Amazon DynamoDB.
DynamoDB est un service de base de données NoSQL entièrement géré. Vous pouvez utiliser DynamoDB pour créer une table de base de données capable de stocker et de récupérer n'importe quelle quantité de données, ainsi que de traiter n'importe quel niveau de trafic des demandes. DynamoDB répartit automatiquement les données et le trafic de la table sur un nombre suffisant de serveurs afin de gérer la capacité de requêtes spécifiée et le volume de données stockées, tout en assurant la cohérence et la rapidité des performances. Pour plus d'informations, consultez [Amazon DynamoDB sur](https://aws.amazon.com/dynamodb/) le site Web. AWS
La création de cet échantillon peut entraîner des frais sur votre AWS compte. Il peut s'agir de frais pour des services tels qu'Amazon EC2 et DynamoDB. Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Pour plus d'informations sur les offres AWS de base de données supplémentaires, consultez [Amazon Relational Database Service (RDS](https://aws.amazon.com/rds/)) [ ElastiCache,](https://aws.amazon.com/elasticache/) [Amazon et Amazon Redshift](https://aws.amazon.com/redshift/) sur le site Web. AWS Voir aussi [AWS Database Migration Service](https://aws.amazon.com/dms/) sur le site web AWS .
+ [Conditions préalables](#sample-dynamodb-prereqs)
+ [Étape 1 : Installer et configurer la AWS CLI, le AWS CloudShell ou les deux dans votre environnement](#sample-dynamodb-cli-setup)
+ [Étape 2 : créer une table](#sample-dynamodb-create-table)
+ [Étape 3 : ajouter un élément à la table](#sample-dynamodb-add-item)
+ [Étape 4 : ajouter plusieurs éléments à la table](#sample-dynamodb-add-items)
+ [Étape 5 : créer un index secondaire global](#sample-dynamodb-create-index)
+ [Étape 6 : obtenir des éléments dans la table](#sample-dynamodb-get-items)
+ [Étape 7 : nettoyer](#sample-dynamodb-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : installer et configurer le AWS CLI AWS CloudShell, ou les deux dans votre environnement
Au cours de cette étape, vous utilisez l' AWS Cloud9 IDE pour installer et configurer le AWS CLI AWS CloudShell, ou les deux dans votre environnement afin de pouvoir exécuter des commandes pour interagir avec DynamoDB. Ensuite, vous utilisez la AWS CLI pour exécuter une commande DynamoDB basique pour tester votre installation et votre configuration.
1. Pour configurer la gestion des informations d'identification pour le AWS CLI AWS CloudShell ou pour installer le AWS CLI AWS CloudShell ou les deux dans votre environnement, suivez les étapes 1 et 2 de l'[AWS CLIAWS CloudShell exemple](sample-aws-cli.md) et revenez à cette rubrique. Si vous avez déjà installé et configuré le AWS CLI AWS CloudShell, ou les deux dans votre environnement, vous n'avez pas besoin de le refaire.
1. Testez l'installation et la configuration de l'aws-shell AWS CLI, ou des deux, en exécutant la **`list-tables`**commande DynamoDB depuis une session de terminal de votre environnement pour répertorier vos tables DynamoDB existantes, le cas échéant. (Pour démarrer une nouvelle session de terminal, dans la barre de menus, choisissez **Windows (Fenêtre)**, **New Terminal (Nouveau terminal)**.
```
aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables # For the aws-shell.
```
**Note**
Dans cet exemple, si vous utilisez aws-shell, omettez `aws` dans chaque commande commençant par `aws`. Pour démarrer aws-shell, exécutez la commande ** `aws-shell` **. Pour arrêter aws-shell, exécutez la commande ** `.exit` ** ou ** `.quit` **.
Si cette commande réussit, elle génère un tableau `TableNames` contenant une liste de tables DynamoDB existantes que vous possédez déjà. Si vous n'avez pas encore de tables DynamoDB, le tableau `TableNames` sera vide.
```
{
"TableNames": []
}
```
Si vous avez des tables DynamoDB, le tableau `TableNames` contient une liste des noms de table.
## Étape 2 : Création d'une table
Au cours de cette étape, vous créez une table dans DynamoDB et spécifiez le nom, la disposition, la clé primaire simple et les paramètres de débit de données de la table.
Cet exemple de table, nommé `Weather`, contient des informations sur les prévisions météorologiques pour quelques villes aux États-Unis. La table contient les types d'informations suivants (dans DynamoDB, chaque information est nommée *attribut*) :
+ ID de ville unique obligatoire (`CityID`)
+ Date de prévision obligatoire (`Date`)
+ Nom de la ville (`City`)
+ Nom de l'état (`State`)
+ Prévisions météorologiques (`Conditions`)
+ Prévisions de températures (`Temperatures`)
+ Prévisions des maximales en degrés Fahrenheit (`HighF`)
+ Prévisions des minimales en degrés Fahrenheit (`LowF`)
Pour créer la table, dans une session de terminal dans l' AWS Cloud9 IDE, exécutez la commande **`create-table`**DynamoDB.
```
aws dynamodb create-table \
--table-name Weather \
--attribute-definitions \
AttributeName=CityID,AttributeType=N AttributeName=Date,AttributeType=S \
--key-schema \
AttributeName=CityID,KeyType=HASH AttributeName=Date,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
```
Dans cette commande :
+ `--table-name` représente le nom de table (`Weather` dans cet exemple). Les noms des tables doivent être uniques dans chaque AWS région de votre AWS compte.
+ `--attribute-definitions` représente les attributs qui sont utilisés pour identifier de manière unique les éléments de la table. Chacun des éléments de cette table sont identifiés de manière unique par une combinaison d'`ID` attribut numérique et d'un attribut `Date` représenté sous la forme d'une chaîne au format ISO-8601.
+ `--key-schema` représente le schéma de clé de la table. Cette table dispose d'une clé primaire composite de `CityID` et `Date`. Cela signifie que chaque élément de la table doit posséder une valeur d'attribut `CityID` et une valeur d'attribut `Date`, mais deux éléments de la table ne peuvent pas avoir la même valeur d'attribut `CityID` et de valeur d'attribut `Date`.
+ `--provisioned-throughput` représente la capacité de lecture/écriture de la table. DynamoDB autorise jusqu'à 5 lectures fortement cohérentes par seconde pour les éléments d'une taille allant jusqu'à 4 Ko, ou jusqu'à 5 lectures cohérentes à terme (eventually consistent) par seconde pour les éléments d'une taille allant jusqu'à 4 Ko. DynamoDB permet également jusqu'à 5 écritures par seconde pour les éléments d'une taille allant jusqu'à 1 Ko.
**Note**
La définition d'un débit provisionné plus élevé peut entraîner des frais supplémentaires pour votre AWS compte.
Pour plus d'informations sur cette commande DynamoDB et sur d'autres, consultez [dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html) dans la *Référence des commandes AWS CLI *.
Si cette commande réussit, elle affiche des informations récapitulatives sur la nouvelle table qui est en cours de création. Pour confirmer que la table est créée avec succès, exécutez la commande DynamoDB** `describe-table` ** en spécifiant le nom de la table (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Une fois la table créée avec succès, la valeur `TableStatus` `CREATING` devient `ACTIVE`. Ne passez pas à l'étape suivante avant que la table n'ait été créée avec succès.
## Étape 3 : Ajouter un élément à la table
Dans cette étape, vous ajoutez un élément à la table que vous venez de créer.
1. Créez un fichier nommé `weather-item.json` avec le contenu suivant. Pour créer un nouveau fichier, dans la barre de menus, choisissez **File (Fichier)**, **New File (Nouveau fichier)**. Pour l'enregistrer, choisissez **File**, **Save**.
```
{
"CityID": { "N": "1" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "46" }
}
}
}
```
Dans ce code, `N` représente une valeur d'attribut qui est un nombre. `S` est une valeur d'attribut de chaîne. `M` est un attribut de carte qui est un ensemble de paires attribut/valeur. Vous devez spécifier un type de données d'attribut chaque fois que vous utilisez des éléments. Pour connaître les types de données d'attribut disponibles supplémentaires, consultez [Type de données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) dans le *Guide du développeur Amazon DynamoDB*.
1. Exécutez la commande DynamoDB** `put-item` **, en spécifiant le nom de la table (`--table-name`) et le chemin de l'élément au format JSON (`--item`).
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
Si la commande réussit, elle s'exécute sans erreur, et aucun message de confirmation ne s'affiche.
1. Pour confirmer le contenu actuel de la table, exécutez la commande DynamoDB** `scan` **, en spécifiant le nom de la table (`--table-name`).
```
aws dynamodb scan --table-name Weather
```
Si la commande réussit, les informations récapitulatives sur la table et l'élément que vous venez d'ajouter s'affiche.
## Étape 4 : Ajouter plusieurs éléments à la table
Dans cette étape, vous ajoutez plusieurs éléments supplémentaires à la table `Weather`.
1. Créez un fichier nommé `more-weather-items.json` avec le contenu suivant.
```
{
"Weather": [
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "52" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Thunderstorms" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "51" },
"LowF": { "N": "41" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain Showers" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "39" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "40" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Partly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "54" },
"LowF": { "N": "37" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Mostly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "53" },
"LowF": { "N": "37" }
}
}
}
}
}
]
}
```
Dans ce code, 8 objets `Item` définissent les 8 articles à ajouter à la table, similaire à l'élément unique défini dans l'étape précédente. Toutefois, lorsque vous exécutez la commande DynamoDB** `batch-write-item` ** à l'étape suivante, vous devez fournir un objet au format JSON qui inclut chaque objet `Item` dans un objet `PutRequest` contenant. Vous devez ensuite inclure ces objets `PutRequest` dans une baie parent qui possède le même nom que la table.
1. Exécutez la commande DynamoDB** `batch-write-item` **, en spécifiant le chemin des éléments au format JSON à ajouter (`--request-items`).
```
aws dynamodb batch-write-item \
--request-items file://more-weather-items.json
```
Si la commande réussit, elle affiche le message suivant, confirmant que les éléments ont été ajoutés avec succès.
```
{
"UnprocessedItems": {}
}
```
1. Pour confirmer le contenu actuel de la table, réexécutez la commande DynamoDB** `scan` **.
```
aws dynamodb scan --table-name Weather
```
Si la commande réussit, 9 articles sont désormais affichés.
## Étape 5 ; Créer un index secondaire global
L'exécution de la commande DynamoDB** `scan` ** pour obtenir des informations sur les éléments peut être lente, en particulier lorsque la taille d'une table s'accroît ou si le type d'informations que vous souhaitez obtenir est complexe. Vous pouvez créer un ou plusieurs index secondaires pour accélérer les choses et faciliter l'obtention d'informations. Au cours de cette étape, vous découvrez deux types d'index secondaires que DynamoDB prend en charge pour cela. Ils sont nommés *index secondaire local* et *index secondaire global*. Puis, vous créez un index secondaire global.
Pour comprendre ces types d'index secondaire, vous devez d'abord connaître les clés primaires, qui identifient de manière unique les éléments d'une table. DynamoDB prend en charge une *clé primaire simple* ou une *clé primaire composite*. Une clé primaire simple possède un attribut unique, et cette valeur d'attribut doit être unique pour chaque élément de la table. Cet attribut est également connu en tant que *clé de partition* (ou *attribut de hachage*), que DynamoDB peut utiliser pour partitionner des éléments pour un accès plus rapide. Une table peut également avoir une clé primaire composite, qui contient deux attributs. Le premier attribut est la clé de partition, et le deuxième est une *clé de tri* (également nommée *attribut de plage*). Dans une table possédant une clé primaire composite, deux éléments peuvent avoir la même valeur de clé de partition, mais ils ne peuvent pas avoir aussi la même valeur de clé de tri. La table `Weather` a une clé primaire composite.
Un index secondaire local possède la même clé de partition que la table elle-même, mais ce type d'index peut avoir une clé de tri différente. Un index secondaire global peut avoir une clé de partition et une clé de tri qui sont tous deux différents de la table elle-même.
Par exemple, vous pouvez déjà utiliser la clé primaire pour accéder à des éléments `Weather` par `CityID`. Pour accéder à des éléments `Weather` par `State`, vous pouvez créer un index secondaire local qui dispose d'une clé de partition de `CityID` (elle doit être identique à la table elle-même) et une clé de tri de `State`. Pour accéder à des éléments `Weather` par `City`, vous pouvez créer un index secondaire global qui possède une clé de partition de `City` et une clé de tri de `Date`.
Vous pouvez créer des index secondaires locaux uniquement pendant que vous créez une table. La table `Weather` existant déjà, vous ne pouvez pas y ajouter des index secondaires locaux. Toutefois, vous pouvez ajouter des index secondaires globaux. Essayez d'en ajouter un à présent.
**Note**
La création d'index secondaires peut entraîner des frais supplémentaires sur votre compte AWS .
1. Créez un fichier nommé `weather-global-index.json` avec le contenu suivant.
```
[
{
"Create": {
"IndexName": "weather-global-index",
"KeySchema": [
{
"AttributeName": "City",
"KeyType": "HASH"
},
{
"AttributeName": "Date",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"State",
"Conditions",
"Temperatures"
]
},
"ProvisionedThroughput": {
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
}
}
}
]
```
Dans ce code :
+ Le nom de l'index secondaire global est `weather-global-index`.
+ L'attribut `City` est la clé de partition (attribut de hachage), et l'attribut `Date` est la clé de tri (attribut d'intervalle).
+ `Projection` définit les attributs à récupérer par défaut (en plus de l'attribut de hachage et de n'importe quel attribut de plage) pour chaque élément correspondant à une recherche de table qui utilise cet index. Dans cet exemple, les attributs `State`, `Conditions`, `HighF` (une partie de `Temperatures`) et `LowF` (également une partie de `Temperatures`) (ainsi que les attributs `City` et `Date`) sont récupérées pour chaque élément correspondant.
+ De même que les tables, un index secondaire global doit définir ses paramètres de débit provisionné.
+ Les paramètres `IndexName`, `KeySchema`, `Projection` et `ProvisionedThroughput` doivent être contenus dans un objet `Create`, qui définit l'index secondaire global à créer lorsque vous exécutez la commande DynamoDB** `update-table` ** à l'étape suivante.
1. Exécutez la commande DynamoDB** `update-table` **.
```
aws dynamodb update-table \
--table-name Weather \
--attribute-definitions \
AttributeName=City,AttributeType=S AttributeName=Date,AttributeType=S \
--global-secondary-index-updates file://weather-global-index.json
```
Dans cette commande :
+ `--table-name` est le nom de la table à mettre à jour.
+ `--attribute-definitions` sont les attributs à inclure dans l'index. La clé de partition est toujours répertoriée en premier, et une clé de tri est toujours répertoriée en deuxième.
+ `--global-secondary-index-updates` est le chemin d'accès au fichier qui définit l'index secondaire global.
Si cette commande réussit, elle affiche des informations récapitulatives sur le nouvel index secondaire global qui est en cours de création. Pour confirmer que l'index secondaire global est créé avec succès, exécutez la commande DynamoDB** `describe-table` ** en spécifiant le nom de la table (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Lorsque l'index secondaire global est créé avec succès, la valeur `TableStatus` `UPDATING` devient `ACTIVE`, et la valeur `IndexStatus` `CREATING` devient `ACTIVE`. Ne passez pas à l'étape suivante avant que l'index secondaire global n'ait été créé avec succès. Cela peut prendre plusieurs minutes.
## Étape 6 : Obtenir des éléments dans la table
Il existe plusieurs moyens d'obtenir des éléments depuis des tables. Au cours de cette étape, vous obtenez des éléments à l'aide de la clé primaire de la table, à l'aide d'autres attributs de la table, et à l'aide de l'index secondaire global.
### Pour obtenir un seul élément à partir d'une table en fonction de la valeur de clé primaire d'un élément
Si vous connaissez la valeur clé primaire d'un élément, vous pouvez obtenir l'élément correspondant en exécutant la commande DynamoDB ** `get-item` **, ** `scan` **, ou ** `query` **. Voici les principales différences dans ces commandes :
+ ** `get-item` ** renvoie un ensemble d'attributs pour l'élément possédant la clé primaire donnée.
+ ** `scan` ** renvoie un ou plusieurs éléments et attributs d'élément en accédant à chaque élément dans une table ou un index secondaire.
+ ** `query` ** trouve les éléments d'après les valeurs de clé primaire. Vous pouvez interroger n'importe quel table ou index secondaire comportant une clé primaire composite (clé de partition et clé de tri).
Dans cet exemple, voici comment utiliser chacune de ces commandes pour obtenir l'élément qui contient la valeur d'attribut `CityID` de `1` et la valeur d'attribut `Date` de `2017-04-12`.
1. Pour exécuter la commande DynamoDB** `get-item` **, spécifiez le nom de la table (`--table-name`), la valeur clé primaire (`--key`) et les valeurs d'attribut de l'élément à afficher (`--projection-expression`). `Date` étant un mot-clé réservé dans DynamoDB, vous devez également fournir un alias pour la valeur d'attribut `Date` (`--expression-attribute-names`). (`State` est également un mot-clé réservé ; un alias lui sera attribué dans les étapes ultérieures.)
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }' \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
Dans cette commande et les autres, pour afficher tous les attributs de l'élément, n'incluez pas `--projection-expression`. Dans cet exemple, étant donné que vous n'incluez pas `--projection-expression`, vous n'avez pas non plus besoin d'inclure `--expression-attribute-names`.
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'
```
1. Pour exécuter la commande DynamoDB** `scan` **, spécifiez :
+ Nom de la table (`--table-name`).
+ La recherche à exécuter (`--filter-expression`).
+ Les critères de recherche à utiliser (`--expression-attribute-values`).
+ Les types d'attributs à afficher pour l'élément correspondant (`--select`).
+ Les valeurs d'attribut pour l'élément à afficher (`--projection-expression`).
+ Si l'un de vos attributs utilise les mots-clés réservés dans DynamoDB, les alias de ces attributs (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
1. Pour exécuter la commande DynamoDB** `query` **, spécifiez :
+ Nom de la table (`--table-name`).
+ La recherche à exécuter (`--key-condition-expression`).
+ Les valeurs d'attribut à utiliser dans la recherche (`--expression-attribute-values`).
+ Les types d'attributs à afficher pour l'élément correspondant (`--select`).
+ Les valeurs d'attribut pour l'élément à afficher (`--projection-expression`).
+ Si l'un de vos attributs utilise les mots-clés réservés dans DynamoDB, les alias de ces attributs (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--key-condition-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
Notez que la commande ** `scan` ** a eu besoin d'analyser les 9 éléments pour obtenir le résultat, tandis que la commande ** `query` ** n'a eu besoin d'analyser qu'1 élément.
### Pour obtenir plusieurs éléments à partir d'une table en fonction des valeurs de clé primaire des éléments
Si vous connaissez les valeurs de clé primaire des éléments, vous pouvez obtenir les éléments correspondants en exécutant la commande DynamoDB** `batch-get-item` **. Dans cet exemple, voici comment utiliser les éléments qui contiennent la valeur d'attribut `CityID` de `3` et les valeurs d'attribut `Date` de `2017-04-13` ou `2017-04-14`.
Exécutez la commande DynamoDB** `batch-get-item` **, en spécifiant le chemin d'accès à un fichier qui décrit les éléments à obtenir (`--request-items`).
```
aws dynamodb batch-get-item --request-items file://batch-get-item.json
```
Dans cet exemple, le code dans le fichier `batch-get-item.json` spécifie la recherche dans la table `Weather` d'éléments possédant un `CityID` de `3` et un `Date` de `2017-04-13` ou `2017-04-14`. Pour chaque élément trouvé, les valeurs d'attribut pour `City`, `State`, `Date` et `HighF` (partie de `Temperatures`) s'affichent, si elles existent.
```
{
"Weather" : {
"Keys": [
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" }
},
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" }
}
],
"ProjectionExpression": "City, #S, #D, Temperatures.HighF",
"ExpressionAttributeNames": { "#S": "State", "#D": "Date" }
}
}
```
### Pour obtenir tous les éléments correspondants à partir d'une table
Si vous connaissez des informations sur les valeurs des attributs de la table, vous pouvez obtenir les éléments correspondants en exécutant la commande DynamoDB** `scan` **. Dans cet exemple, voici comment utiliser les dates lorsque la valeur d'attribut `Conditions` contient `Sunny` et que la valeur d'attribut `HighF` (une partie de `Temperatures`) est supérieure à `53`.
Exécutez la commande DynamoDB** `scan` **, en spécifiant :
+ Nom de la table (`--table-name`).
+ La recherche à exécuter (`--filter-expression`).
+ Les critères de recherche à utiliser (`--expression-attribute-values`).
+ Les types d'attributs à afficher pour l'élément correspondant (`--select`).
+ Les valeurs d'attribut pour l'élément à afficher (`--projection-expression`).
+ Si l'un de vos attributs utilise les mots-clés réservés dans DynamoDB, les alias de ces attributs (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression \
"(contains (Conditions, :sun)) and (Temperatures.HighF > :h)" \
--expression-attribute-values \
'{ ":sun": { "S" : "Sunny" }, ":h": { "N" : "53" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
### Pour obtenir tous les éléments correspondants à partir d'un index secondaire global
Pour effectuer une recherche à l'aide d'un index secondaire global, utilisez la commande DynamoDB** `query` **. Dans cet exemple, voici comment utiliser l'index secondaire `weather-global-index` pour obtenir les prévisions météorologiques pour les villes nommées `Portland` pour les dates du `2017-04-13` et du `2017-04-14`.
Exécutez la commande DynamoDB** `query` **, en spécifiant :
+ Nom de la table (`--table-name`).
+ Nom de l'index secondaire global (`--index-name`).
+ La recherche à exécuter (`--key-condition-expression`).
+ Les valeurs d'attribut à utiliser dans la recherche (`--expression-attribute-values`).
+ Les types d'attributs à afficher pour l'élément correspondant (`--select`).
+ Si l'un de vos attributs utilise les mots-clés réservés dans DynamoDB, les alias de ces attributs (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--index-name weather-global-index \
--key-condition-expression "(City = :city) and (#D between :date1 and :date2)" \
--expression-attribute-values \
'{ ":city": { "S" : "Portland" }, ":date1": { "S": "2017-04-13" }, ":date2": { "S": "2017-04-14" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
## Étape 7 : nettoyer
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez supprimer le tableau. La suppression de la table supprime l'index secondaire global également. Vous devez également supprimer votre environnement.
Pour supprimer la table, exécutez la commande DynamoDB** `delete-table` ** en spécifiant le nom de la table (`--table-name`).
```
aws dynamodb delete-table --table-name Weather
```
Si la commande réussit, des informations sur la table s'affichent, y compris la valeur `TableStatus` de `DELETING`.
Pour confirmer que la table est supprimée avec succès, exécutez la commande DynamoDB** `describe-table` ** en spécifiant le nom de la table (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Si la table est supprimée avec succès, un message contenant la phrase `Requested resource not found` s'affiche.
Pour supprimer votre environnement, consultez [Suppression d'un environnement](delete-environment.md).
# AWS CDK tutoriel pour AWS Cloud9
Ce didacticiel explique comment utiliser le AWS Cloud Development Kit (AWS CDK) dans un environnement de AWS Cloud9 développement. AWS CDK Il s'agit d'un ensemble d'outils logiciels et de bibliothèques que les développeurs peuvent utiliser pour modéliser les composants de AWS l'infrastructure sous forme de code.
AWS CDK Il inclut la bibliothèque AWS Construct que vous pouvez utiliser pour résoudre rapidement de nombreuses tâches AWS. Par exemple, vous pouvez utiliser la construction `Fleet` pour déployer intégralement et en toute sécurité du code pour une flotte d'hôtes. Vous pouvez créer vos propres structures pour modéliser différents éléments de vos architectures, les partager avec d'autres personnes, ou les diffuser à la communauté. Pour en savoir plus, consultez le [Guide du développeur AWS Cloud Development Kit](https://docs.aws.amazon.com/cdk/v2/guide/home.html).
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 comme Amazon EC2, Amazon SNS et Amazon SQS. Pour plus d'informations, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/), [Tarification Amazon SNS](https://aws.amazon.com/sns/pricing/) et [Tarification Amazon SQS](https://aws.amazon.com/sqs/pricing/).
**Topics**
+ [Conditions préalables](#sample-cdk-prereqs)
+ [Étape 1 : Installer les outils requis](#sample-cdk-install)
+ [Étape 2 : Ajouter du code](#sample-cdk-code)
+ [Étape 3 : Exécuter le code](#sample-cdk-run)
+ [Étape 4 : nettoyer](#sample-cdk-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Installer les outils requis
Au cours de cette étape, vous installez dans votre environnement tous les outils AWS CDK nécessaires pour exécuter un exemple écrit dans le langage TypeScript de programmation.
1. [Node Version Manager](#sample-cdk-install-nvm), ou ** `nvm` **, que vous utilisez pour installer Node.js ultérieurement.
1. [Node.js](#sample-cdk-install-nodejs), qui est requis par l'exemple et contient le Node Package Manager, ou **`npm`**, que vous utilisez pour l'installation TypeScript et les AWS CDK versions ultérieures.
1. [TypeScript](#sample-cdk-install-typescript), qui est requis par cet exemple. (Il prend AWS CDK également en charge plusieurs autres langages de programmation.)
1. Le [CDK AWS](#sample-cdk-install-cdk).
### Étape 1.1 : Installer le Gestionnaire de version de nœud (nvm)
1. Lors d'une session de terminal dans l' AWS Cloud9 IDE, assurez-vous que les dernières mises à jour de sécurité et corrections de bogues sont installées. Pour ce faire, exécutez la commande ** `yum update` ** (pour Amazon Linux) ou ** `apt update` ** (pour Ubuntu Server). (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window**, **Nouveau Terminal**.)
Pour Amazon Linux :
```
sudo yum -y update
```
Pour Ubuntu Server :
```
sudo apt update
```
1. Vérifiez si ** `nvm` ** est déjà installé. Pour ce faire, exécutez la commande ** `nvm` ** avec l'option ** `--version` **.
```
nvm --version
```
En cas de réussite, la sortie contient le numéro de version de **`nvm`**, et vous pouvez passer directement à [Étape 1.2 : Installer Node.js.](#sample-cdk-install-nodejs).
1. Téléchargez et installez ** `nvm` **. Pour ce faire, exécutez le script d'installation. Dans cet exemple, v0.33.0 est installé, mais vous pouvez vérifier la dernière version de ** `nvm` ** [ici](https://github.com/nvm-sh/nvm#installing-and-updating).
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Commencez à utiliser ** `nvm` **. Vous pouvez fermer la session de terminal et la redémarrer, ou approvisionner le fichier `~/.bashrc` qui contient les commandes pour charger ** `nvm` **.
```
. ~/.bashrc
```
### Étape 1.2 : Installer Node.js.
1. Vérifiez si vous avez déjà installé Node.js et, si vous le faites, assurez-vous qu'il s'agit de la version 16.17.0 ou d'une version supérieure. **Cet exemple a été testé avec Node.js 16.17.0.** Pour vérifier, avec la séance de terminal toujours ouverte dans l'IDE, exécutez la commande ** `node` ** avec l'option ** `--version` **.
```
node --version
```
Si Node.js est bien installé, la sortie contient le numéro de version. Si le numéro de version est v16.17.0, passez directement à [Étape 1.3 : Installation TypeScript](#sample-cdk-install-typescript).
1. Installez Node.js 16 en exécutant la **`nvm`**commande avec l'**`install`**action.
**Note**
Vous pouvez également exécuter **`nvm install node`**pour installer la version de support à long terme (LTS) de Node.js. AWS Cloud9 support suit la version LTS de Node.js.
```
nvm install v16
```
1. Commencez à utiliser Node.js 16. Pour ce faire, exécutez la commande ** `nvm` ** avec l'action ** `alias` **, le numéro de version d'alias et la version à utiliser pour cet alias, comme suit.
```
nvm alias default 16
```
**Note**
La commande précédente définit Node.js 16 comme version par défaut de Node.js. Vous pouvez également exécuter la commande ** `nvm` ** ainsi que l'action ** `use` ** au lieu de l'action ** `alias` ** (par exemple, ** `nvm use 16.17.0` **). Cependant, l'action ** `use` ** fait que cette version de Node.js s'exécute uniquement lorsque la session de terminal actuelle est en cours d'exécution.
1. Pour confirmer que vous utilisez Node.js 16, réexécutez la **`node --version`**commande. Si la bonne version est installée, la sortie contient la version v16.
### Étape 1.3 : Installation TypeScript
1. Vérifiez si vous l'avez déjà TypeScript installé. Pour ce faire, la session du terminal étant toujours ouverte dans l'IDE, exécutez le TypeScript compilateur de ligne de commande avec l'**`--version`**option.
```
tsc --version
```
Si vous l'avez TypeScript installé, la sortie contient le numéro de TypeScript version. S' TypeScript il est installé, passez directement à[Étape 1.4 : Installation du AWS CDK](#sample-cdk-install-cdk).
1. Installez TypeScript. Pour ce faire, exécutez la **`npm`**commande avec l'**`install`**action, l'**`-g`**option et le nom du TypeScript package. Cela s'installe TypeScript en tant que package global dans l'environnement.
```
npm install -g typescript
```
1. Confirmez qu' TypeScript il est installé. Pour ce faire, exécutez le TypeScript compilateur en ligne de commande avec l'**`--version`**option.
```
tsc --version
```
S'il TypeScript est installé, la sortie contient le numéro de TypeScript version.
### Étape 1.4 : Installation du AWS CDK
1. Vérifiez si vous l'avez déjà AWS CDK installé. Pour ce faire, avec la session de terminal toujours ouverte dans l'IDE, exécutez la commande ** `cdk` ** avec l'option ** `--version` **.
```
cdk --version
```
Si le AWS CDK est installé, la sortie contient les numéros de AWS CDK version et de build. Passez directement à [Étape 2 : Ajouter du code](#sample-cdk-code).
1. Installez le AWS CDK en exécutant la **`npm`**commande accompagnée de l'`install`action, du nom du AWS CDK package à installer et de l'`-g`option permettant d'installer le package globalement dans l'environnement.
```
npm install -g aws-cdk
```
1. Vérifiez que le AWS CDK est installé et correctement référencé. Pour ce faire, exécutez la commande ** `cdk` ** avec l'option ** `--version` **.
```
cdk --version
```
En cas de succès, les numéros de AWS CDK version et de version sont affichés.
## Étape 2 : Ajouter du code
Au cours de cette étape, vous créez un exemple de TypeScript projet contenant tout le code source dont vous avez besoin pour déployer une AWS CloudFormation pile par programmation. AWS CDK Cette pile crée une rubrique Amazon SNS et une file d'attente Amazon SQS dans AWS votre compte, puis abonne la file d'attente à la rubrique.
1. Avec la séance de terminal toujours ouvert dans l'IDE, créez un répertoire pour stocker le code source du projet, par exemple un répertoire `~/environment/hello-cdk` dans votre environnement. Puis basculez sur ce répertoire.
```
rm -rf ~/environment/hello-cdk # Remove this directory if it already exists.
mkdir ~/environment/hello-cdk # Create the directory.
cd ~/environment/hello-cdk # Switch to the directory.
```
1. Configurez le répertoire en tant que projet de TypeScript langue pour AWS CDK. Pour ce faire, exécutez la commande ** `cdk` ** avec l'action ** `init` **, le modèle ** `sample-app` ** et l'option ** `--language` **, ainsi que le nom du langage de programmation.
```
cdk init sample-app --language typescript
```
Cela crée les fichiers et sous-répertoires suivants dans le répertoire.
+ Un sous-répertoire masqué `.git` et un fichier masqué `.gitignore`, ce qui rend le projet compatible avec des outils de contrôle de source tel que Git.
+ Un sous-répertoire `lib`, qui inclut un fichier `hello-cdk-stack.ts`. Ce fichier contient le code de votre AWS CDK pile. Ce code est décrit dans l'étape suivante de cette procédure.
+ Un sous-répertoire `bin`, qui inclut un fichier `hello-cdk.ts`. Ce fichier contient le point d'entrée de votre AWS CDK application.
+ Un répertoire `node_modules` qui contient les packages de code pris en charge, que l'application et la pile peuvent utiliser selon leurs besoins.
+ Un fichier masqué `.npmignore`, qui répertorie les types de sous-répertoires et les fichiers dont ** `npm` ** n'a pas besoin lorsqu'il crée le code.
+ Un fichier `cdk.json`, qui contient les informations pour exécuter la commande ** `cdk` ** plus facilement.
+ Un fichier `package-lock.json`, qui contient des informations que ** `npm` ** peut utiliser pour réduire la création et l'exécution d'erreurs éventuelles.
+ Un fichier `package.json`, qui contient les informations pour exécuter la commande ** `npm` ** plus facilement et avec probablement moins d'erreurs de création et d'exécution.
+ Un `README.md` fichier répertoriant les commandes utiles que vous pouvez exécuter avec **`npm`**et le AWS CDK.
+ Un fichier `tsconfig.json`, qui contient les informations pour exécuter la commande ** `tsc` ** plus facilement et avec probablement moins d'erreurs de création et d'exécution.
1. Dans la fenêtre **Environnement**, ouvrez le fichier `lib/hello-cdk-stack.ts` et recherchez le code suivant dans le fichier.
```
import sns = require('@aws-cdk/aws-sns');
import sqs = require('@aws-cdk/aws-sqs');
import cdk = require('@aws-cdk/cdk');
export class HelloCdkStack extends cdk.Stack {
constructor(parent: cdk.App, name: string, props?: cdk.StackProps) {
super(parent, name, props);
const queue = new sqs.Queue(this, 'HelloCdkQueue', {
visibilityTimeoutSec: 300
});
const topic = new sns.Topic(this, 'HelloCdkTopic');
topic.subscribeQueue(queue);
}
}
```
+ Les `Topic` classes `Stack``App`,`StackProps`,`Queue`, et représentent respectivement une CloudFormation pile et ses propriétés, un programme exécutable, une file d'attente Amazon SQS et une rubrique Amazon SNS.
+ La `HelloCdkStack` classe représente la CloudFormation pile de cette application. Cette pile contient la nouvelle file d'attente Amazon SQS et la rubrique Amazon SNS pour cette application.
1. Dans la fenêtre **Environnement**, ouvrez le fichier `bin/hello-cdk.ts` et recherchez le code suivant dans le fichier.
```
#!/usr/bin/env node
import cdk = require('@aws-cdk/cdk');
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack');
app.run();
```
Ce code charge, instancie, puis exécute la classe `HelloCdkStack` à partir du fichier `lib/hello-cdk-stack.ts`.
1. **`npm`**Utilisez-le pour exécuter le TypeScript compilateur afin de vérifier les erreurs de codage, puis d'activer le AWS CDK pour exécuter le `bin/hello-cdk.js` fichier du projet. Pour ce faire, dans le répertoire racine du projet, exécutez la commande ** `npm` ** avec l'action ** `run` ** , en spécifiant la valeur de la commande ** `build` ** dans le fichier `package.json`, comme suit.
```
npm run build
```
La commande précédente exécute le TypeScript compilateur, qui ajoute des supports `bin/hello-cdk.d.ts` et `lib/hello-cdk-stack.d.ts` des fichiers. Le compilateur transpile également les fichiers `hello-cdk-stack.ts` et `hello-cdk.ts` dans les fichiers `hello-cdk-stack.js` et `hello-cdk.js`.
## Étape 3 : Exécuter le code
Au cours de cette étape, vous demandez AWS CDK à la de créer un modèle de CloudFormation pile basé sur le code du `bin/hello-cdk.js` fichier. Vous lui demandez ensuite de AWS CDK déployer la pile, qui crée la rubrique Amazon SNS et la file d'attente Amazon SQS, puis abonne la file d'attente à la rubrique. Vous pouvez alors confirmer que la rubrique et la file d'attente ont été déployées avec succès en envoyant un message à partir de la rubrique pour la file d'attente.
1. Demandez à AWS CDK créer le modèle de CloudFormation pile. Pour ce faire, la séance de terminal toujours ouverte dans l'IDE, à partir du répertoire à la racine du projet, exécutez la commande ** `cdk` ** avec l'action ** `synth` ** et le nom de la pile.
```
cdk synth HelloCdkStack
```
En cas de succès, la sortie affiche la `Resources` section du modèle de CloudFormation pile.
1. La première fois que vous déployez une AWS CDK application dans un environnement pour une combinaison de AWS compte et de AWS région spécifique, vous devez installer une *pile bootstrap*. Cette pile comprend diverses ressources dont elle a AWS CDK besoin pour effectuer ses différentes opérations. Par exemple, cette pile inclut un compartiment Amazon S3 AWS CDK utilisé pour stocker des modèles et des actifs au cours de ses processus de déploiement. Pour installer la pile d'amorçage, exécutez la commande ** `cdk` ** avec l'action ** `bootstrap`**.
```
cdk bootstrap
```
**Note**
Si vous exécutez `cdk bootstrap` sans spécifier d'options, le AWS compte et la AWS région par défaut sont utilisés. Vous pouvez également démarrer un environnement spécifique en spécifiant un profil et une account/Region combinaison. Par exemple :
```
cdk bootstrap --profile test 123456789012/us-east-1
```
1. Demandez-leur d' AWS CDK exécuter le modèle de CloudFormation pile pour déployer la pile. Pour ce faire, à partir du répertoire à la racine du projet, exécutez la commande ** `cdk` ** avec l'action ** `deploy` **, et le nom de la pile.
```
cdk deploy HelloCdkStack
```
En cas de réussite, la sortie affiche que la pile `HelloCdkStack` a été déployée sans erreur.
**Note**
Si le résultat affiche un message indiquant que la pile ne définit pas d'environnement et que les AWS informations d'identification n'ont pas pu être obtenues à partir d'emplacements standard ou qu'aucune région n'a été configurée, assurez-vous que vos AWS informations d'identification sont correctement définies dans l'IDE, puis réexécutez la **`cdk deploy`**commande. Pour de plus amples informations, veuillez consulter [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md).
1. Pour confirmer que la rubrique Amazon SNS et la file d'attente Amazon SQS ont été déployées avec succès, envoyez un message à la rubrique et vérifiez la file d'attente pour voir si le message a été reçu. Pour ce faire, vous pouvez utiliser un outil tel que le AWS Command Line Interface (AWS CLI) ou le AWS CloudShell. Pour plus d'informations sur ces outils, consultez [AWS CLI et tutoriel aws-shell pour AWS Cloud9](sample-aws-cli.md).
Par exemple, pour envoyer un message au sujet, alors que la session du terminal est toujours ouverte dans l'IDE, utilisez la commande AWS CLI pour exécuter la **`publish`**commande Amazon SNS, en fournissant l'objet et le corps du message, la AWS région du sujet et le nom de ressource Amazon (ARN) du sujet.
```
aws sns publish --subject "Hello from the AWS CDK" --message "This is a message from the AWS CDK." --topic-arn arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K
```
Dans la commande précédente, remplacez `arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K` par l'ARN CloudFormation attribué au sujet. Pour obtenir l'ID, vous pouvez exécuter la commande Amazon SNS** `list-topics` **.
```
aws sns list-topics --output table --query 'Topics[*].TopicArn'
```
En cas de réussite, la sortie de la commande ** `publish` ** affiche la valeur `MessageId` pour le message qui a été publié.
Pour vérifier la file d'attente pour le message reçu, exécutez la commande Amazon SQS** `receive-message` **, en fournissant l'URL de la file d'attente.
```
aws sqs receive-message --queue-url https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K
```
Dans la commande précédente, remplacez `https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K` par l'ARN CloudFormation attribué à la file d'attente. Pour obtenir l'URL, vous pouvez exécuter la commande Amazon SQS ** `list-queues` **.
```
aws sqs list-queues --output table --query 'QueueUrls[*]'
```
En cas de réussite, la sortie de la commande ** `receive-message` ** affiche l'information pour le message qui a été reçu.
## Étape 4 : nettoyer
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez fini d'utiliser cet exemple, vous devez supprimer la CloudFormation pile. Cela supprime la rubrique Amazon SNS et la file d'attente Amazon SQS. Vous devez également supprimer l'environnement.
### Étape 4.1 : supprimer la pile
Avec la séance de terminal toujours ouverte dans l'IDE, à partir du répertoire à la racine du projet, exécutez la commande ** `cdk` ** avec l'action ** `destroy` ** et le nom de la pile.
```
cdk destroy HelloCdkStack
```
Lorsque vous êtes invité à supprimer la pile, tapez `y`, puis appuyez sur `Enter`.
En cas de réussite, la sortie affiche que la pile `HelloCdkStack` a été supprimée sans erreur.
### Étape 4.2 : Supprimer l'environnement
Pour supprimer l'environnement, consultez [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# Tutoriel LAMP pour AWS Cloud9
Ce didacticiel vous permet de configurer et d'exécuter LAMP (Linux, Apache Serveur HTTP, MySQL, et PHP) dans un environnement AWS Cloud9 de développement.
Le fait de suivre ce didacticiel et de créer cet exemple peut entraîner des frais pour votre Compte AWS. Cela inclut les frais éventuels Services AWS tels qu'Amazon Elastic Compute Cloud (Amazon EC2). Pour plus d'informations, consultez [Amazon EC2 Pricing](https://aws.amazon.com/ec2/pricing/).
**Topics**
+ [Prérequis](#sample-lamp-prereqs)
+ [Étape 1 : Installation des outils](#sample-lamp-install-tools)
+ [Étape 2 : Configuration MySQL](#sample-lamp-setup-mysql)
+ [Étape 3 : Configuration d'un site Web](#sample-lamp-apache)
+ [Étape 4 : nettoyer](#sample-lamp-clean-up)
## Prérequis
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement AWS Cloud9 EC2 de développement existant.** Cet exemple suppose que vous disposez déjà d'un EC2 environnement connecté à une EC2 instance Amazon exécutant Amazon Linux ou Ubuntu Serveur. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Installation des outils
Dans cette étape, vous installez les outils suivants :
+ Apache HTTP Server, un hôte de serveur Web.
+ PHP, un langage de scripting particulièrement adapté pour le développement Web, qui peut être intégré à HTML.
+ MySQL, un système de gestion de base de données.
Vous terminez ensuite cette étape en commençant Apache Serveur HTTP, puis MySQL.
1. Assurez-vous que les mises à jour de sécurité et correctifs de bogues les plus récents sont installés sur l'instance. Pour ce faire, dans une session de terminal dans l' AWS Cloud9 IDE, exécutez **`yum update`**for (Amazon Linux) ou **`apt update`**for (Ubuntu commande Server). (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window**, **Nouveau Terminal**.)
Pour Amazon Linux :
```
sudo yum -y update
```
Dans Ubuntu Serveur :
```
sudo apt -y update
```
1. Vérifiez si Apache Le serveur HTTP est déjà installé. Pour ce faire, exécutez le **`httpd -v`**(pour Amazon Linux) ou **`apache2 -v`**(pour Ubuntu commande Server).
En cas de succès, la sortie contient le Apache Numéro de version du serveur HTTP.
Si un message d'erreur s'affiche, installez Apache Serveur HTTP en exécutant la **`install`**commande.
Pour Amazon Linux :
```
sudo yum install -y httpd24
```
Dans Ubuntu Serveur :
```
sudo apt install -y apache2
```
1. Confirmez si PHP est déjà installé en exécutant la **`php -v`**commande.
Si PHP est installé, la sortie contient le numéro de version de PHP.
Si un message d'erreur s'affiche, installez PHP en exécutant la commande **`install`**.
Pour Amazon Linux :
```
sudo yum install -y php56
```
Dans Ubuntu Serveur :
```
sudo apt install -y php libapache2-mod-php php-xml
```
1. Confirmez si MySQL est déjà installé en exécutant la **`mysql --version`**commande.
En cas de succès, la sortie contient le MySQL numéro de version.
Si un message d'erreur s'affiche, installez MySQL en exécutant la **`install`**commande.
Pour Amazon Linux :
```
sudo yum install -y mysql-server
```
Dans Ubuntu Serveur :
```
sudo apt install -y mysql-server
```
1. Après avoir installé Apache Serveur HTTP, PHP, et MySQL, démarrer Apache Serveur HTTP, puis confirmez qu'il a démarré en exécutant la commande suivante.
Pour Amazon Linux (vous devrez peut-être exécuter cette commande deux fois) :
```
sudo service httpd start && sudo service httpd status
```
Dans Ubuntu Serveur (pour revenir à l'invite de commande, appuyez sur`q`) :
```
sudo service apache2 start && sudo service apache2 status
```
1. Démarrer MySQL, puis confirmez qu'il a démarré en exécutant la commande suivante.
Pour Amazon Linux :
```
sudo service mysqld start && sudo service mysqld status
```
Dans Ubuntu Serveur (pour revenir à l'invite de commande, appuyez sur`q`) :
```
sudo service mysql start && sudo service mysql status
```
## Étape 2 : Configuration MySQL
Au cours de cette étape, vous configurez MySQL à suivre MySQL les meilleures pratiques en matière de sécurité. Ces bonnes pratiques de sécurité incluent la définition d'un mot de passe pour les comptes root et la suppression des comptes root accessibles depuis l'extérieur de l'hôte local. Parmi les autres bonnes pratiques à prendre en compte, citons la suppression des utilisateurs anonymes, la suppression de la base de données de test et la suppression des privilèges permettant à quiconque d'accéder à des bases de données dont le nom commence par `test_`.
Vous terminez ensuite cette étape en vous entraînant à démarrer puis à sortir du MySQL client en ligne de commande.
1. Mettre en œuvre MySQL meilleures pratiques en matière de sécurité pour MySQL installation en exécutant la commande suivante dans une session de terminal dans l' AWS Cloud9 IDE.
```
sudo mysql_secure_installation
```
1. Lorsque vous y êtes invité, répondez aux questions suivantes comme spécifié.
Pour Amazon Linux :
1. **Saisir le mot de passe racine actuel (Entrée s'il n'y en a pas)** – Appuyez sur `Enter` (s'il n'y en a pas).
1. **Définir un mot de passe racine**Saisissez `Y` et appuyez sur `Enter`.
1. **Nouveau mot de passe** – Entrez un mot de passe et appuyez sur `Enter`.
1. **Entrer à nouveau le nouveau mot de passe** – Entrez à nouveau le mot de passe et appuyez sur `Enter`. (Veillez à stocker le mot de passe dans un emplacement sûr en vue d'une utilisation ultérieure.)
1. **Supprimer les utilisateurs anonymes** – Saisissez `Y` et appuyez sur `Enter`.
1. **Interdire la connexion racine à distance** – Entrez `Y` et appuyez sur `Enter`.
1. **Supprimer la base de données de test et l'accès à celle-ci** – Entrez `Y` et appuyez sur `Enter`.
1. **Recharger les tables de privilèges maintenant** – Saisissez `Y` et appuyez sur `Enter`.
Dans Ubuntu Serveur :
1. **Would you like to set up VALIDATE PASSWORD plugin** (Souhaitez-vous configurer le plug-in VALIDATE PASSWORD) : saisissez `y` et appuyez sur `Enter`.
1. **There are three levels of password validation policy** (Il existe trois niveaux de politique de validation de mot de passe : saisissez `0`, `1` ou `2`, puis appuyez sur `Enter`.
1. **New password** (Nouveau mot de passe) : saisissez un mot de passe et appuyez sur `Enter`.
1. **Re-enter new password** (Saisir à nouveau le nouveau mot de passe) : saisissez à nouveau le mot de passe et appuyez sur `Enter`. Assurez-vous que le mot de passe est stocké dans un emplacement sûr en vue d'une utilisation ultérieure.
1. **Do you wish to continue with the password provided** (Voulez-vous continuer avec le mot de passe fourni) : saisissez `y` et appuyez sur `Enter`.
1. **Remove anonymous users** (Supprimer les utilisateurs anonymes) : saisissez `y` et appuyez sur `Enter`.
1. **Disallow root login remotely** (Interdire la connexion racine à distance) : saisissez `y` et appuyez sur `Enter`.
1. **Remove test database and access to it** (Supprimer la base de données de test et l'accès à celle-ci) : saisissez `y` et appuyez sur `Enter`.
1. **Reload privilege tables now** (Recharger les tables de privilèges maintenant) : saisissez `y` et appuyez sur `Enter`.
1. Pour interagir directement avec MySQL, lancez le MySQL client de ligne de commande en tant qu'utilisateur root en exécutant la commande suivante. Lorsque vous y êtes invité, saisissez le mot de passe de l'utilisateur racine que vous avez défini précédemment, puis appuyez sur `Enter`. L'invite devient `mysql>` alors que vous êtes dans MySQL client en ligne de commande.
```
sudo mysql -uroot -p
```
1. Pour quitter le MySQL client de ligne de commande, exécutez la commande suivante. L'invite redevient `$`.
```
exit;
```
## Étape 3 : Configuration d'un site Web
Au cours de cette étape, vous configurez la racine du site Web par défaut pour Apache Serveur HTTP avec propriétaires et autorisations d'accès recommandés. Vous créez ensuite un PHPpage Web basée sur cette racine de site Web par défaut.
Vous autorisez ensuite le trafic Web entrant à consulter cette page Web en configurant le groupe de sécurité dans Amazon EC2 et la liste de contrôle d'accès réseau (ACL réseau) dans Amazon Virtual Private Cloud (Amazon VPC) associés à cet EC2 environnement. Chaque EC2 environnement doit être associé à la fois à un groupe de sécurité dans Amazon EC2 et à une ACL réseau dans Amazon VPC. Toutefois, même si la liste ACL réseau par défaut dans un Compte AWS autorise tout le trafic entrant et sortant pour l'environnement, le groupe de sécurité par défaut autorise uniquement le trafic entrant à l'aide de SSH sur le port 22. Pour de plus amples informations, veuillez consulter [Paramètres VPC pour les environnements de développement AWS Cloud9](vpc-settings.md).
Vous pouvez ensuite terminer cette étape en consultant la page Web depuis l'extérieur de l'IDE AWS Cloud9 .
1. Configurez la racine du site Web par défaut pour Apache Serveur HTTP (`/var/www/html`) avec propriétaires et autorisations d'accès recommandés. Pour ce faire, exécutez les six commandes suivantes, une par une dans l'ordre suivant, dans une session de terminal dans l' AWS Cloud9 IDE. Pour comprendre l'objectif de chaque commande, lisez les informations qui suivent le caractère `#` après chaque commande.
Pour Amazon Linux :
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ec2-user # Add the user ec2-user (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a apache # Add the user apache (Apache HTTP Server) to the group web-content.
sudo chown -R ec2-user:web-content /var/www/html # Change the owner of /var/www/html and its files to user ec2-user and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
Dans Ubuntu Serveur :
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ubuntu # Add the user ubuntu (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a www-data # Add the user www-data (Apache HTTP Server) to the group web-content.
sudo chown -R ubuntu:web-content /var/www/html # Change the owner of /var/www/html and its files to user ubuntu and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
1. Créez un PHPpage Web basée sur `index.php` le nom du dossier racine du site Web par défaut pour Apache Serveur HTTP (qui est`/var/www/html`) en exécutant la commande suivante.
Pour Amazon Linux :
```
sudo touch /var/www/html/index.php && sudo chown -R ec2-user:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
La commande précédente pour Amazon Linux change également le propriétaire du fichier en`ec2-user`, change le groupe du fichier en`web-content`, et modifie les autorisations du fichier en read/write for the user, and read/execute pour le groupe et les autres.
Dans Ubuntu Serveur :
```
sudo touch /var/www/html/index.php && sudo chown -R ubuntu:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
La commande précédente pour Ubuntu Le serveur remplace également le propriétaire du fichier`ubuntu`, le groupe du fichier et les autorisations du fichier read/write for the user, and read/execute pour le groupe et les autres. `web-content`
Si elles aboutissent, les commandes précédentes créent le fichier `index.php` avec le contenu suivant.
```
```
1. Activez le trafic Web entrant via le port 80 pour afficher la nouvelle page Web en configurant l'ACL réseau dans Amazon VPC et le groupe de sécurité Amazon EC2 associé à cet EC2 environnement. Pour ce faire, exécutez les 8 commandes suivantes, l'une après l'autre, dans l'ordre suivant. Pour comprendre l'objectif de chaque commande, lisez les informations qui suivent le caractère `#` pour chaque commande.
**Important**
L'exécution des commandes suivantes active le trafic Web entrant via le port 80 pour **tous les** EC2 environnements et les EC2 instances Amazon associés au groupe de sécurité et à l'ACL réseau pour cet environnement. Cela peut entraîner l'activation inattendue du trafic Web entrant via le port 80 pour EC2 des environnements et EC2 des instances Amazon autres que celui-ci.
**Note**
Les commandes 2 à 4 suivantes permettent au groupe de sécurité d'autoriser le trafic Web entrant sur le port 80. Si vous avez un groupe de sécurité par défaut qui autorise uniquement le trafic SSH entrant sur le port 22, vous devez exécuter la première commande suivie par ces commandes 2 à 4. Cependant, si vous avez un groupe de sécurité personnalisé qui autorise déjà le trafic Web entrant sur le port 80, vous pouvez ne pas exécuter ces commandes.
Les commandes cinq à huit suivantes permettent à la liste ACL réseau d'autoriser le trafic Web entrant sur le port 80. Si vous avez une liste ACL réseau par défaut qui autorise déjà tout le trafic entrant sur tous les ports, vous pouvez ne pas exécuter ces commandes. Supposons toutefois que vous disposiez d'une liste ACL réseau personnalisée qui n'autorise pas le trafic Web entrant sur le port 80. Ensuite, exécutez la première commande, suivie des commandes cinq à huit.
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Add an inbound rule to the security group to allow all incoming IPv4-based traffic over port 80.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Add an inbound rule to the security group to allow all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10000 --cidr-block 0.0.0.0/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv4-based traffic over port 80. Advanced users: change this suggested rule number as desired.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10100 --ipv6-cidr-block ::/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv6-based traffic over port 80. Advanced users: change this suggested rule number as desired.
```
1. Obtenez l'URL d'accès au fichier `index.php` dans la racine du serveur web. Pour ce faire, exécutez la commande suivante et utilisez un nouvel onglet de navigateur Web ou un autre navigateur Web distinct de l' AWS Cloud9 IDE pour accéder à l'URL qui s'affiche. En cas de succès, la page Web affiche des informations sur Apache Serveur HTTP, MySQL, PHP, et d'autres paramètres connexes.
```
MY_PUBLIC_IP=$(curl http://169.254.169.254/latest/meta-data/public-ipv4) && echo http://$MY_PUBLIC_IP/index.php # Get the URL to the index.php file within the web server root.
```
## Étape 4 : nettoyer
Supposons que vous souhaitiez continuer à utiliser cet environnement mais que vous souhaitiez désactiver le trafic Web entrant via le port 80. Exécutez ensuite les huit commandes suivantes, l'une après l'autre et dans l'ordre indiqué, pour supprimer les règles de trafic entrant correspondantes que vous avez définies précédemment dans le groupe de sécurité et la liste ACL réseau associés à l'environnement. Pour comprendre l'objectif de chaque commande, lisez les informations qui suivent le caractère `#` pour chaque commande.
**Important**
L'exécution des commandes suivantes désactive le trafic Web entrant via le port 80 pour **tous les** EC2 environnements et les EC2 instances Amazon associés au groupe de sécurité et à l'ACL réseau pour cet environnement. Cela peut entraîner la désactivation inattendue du trafic Web entrant via le port 80 pour les EC2 environnements et les EC2 instances Amazon autres que celui-ci.
**Note**
Les commandes cinq à huit suivantes suppriment les règles existantes pour empêcher la liste ACL réseau d'autoriser le trafic Web entrant sur le port 80. Si vous avez une liste ACL réseau par défaut qui autorise déjà tout le trafic entrant sur tous les ports, vous pouvez ne pas exécuter ces commandes. Supposons toutefois que vous disposiez d'une liste ACL réseau personnalisée avec des règles existantes qui autorisent le trafic Web entrant via le port 80 et que vous souhaitiez supprimer ces règles. Ensuite, vous devez exécuter la première commande, suivie des cinquième à huitième commandes.
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Delete the existing inbound rule from the security group to block all incoming IPv4-based traffic over port 80.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Delete the existing inbound rule from the security group to block all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10000 # Delete the existing inbound rule from the network ACL to block all IPv4-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10100 # Delete the existing inbound rule from the network ACL to block all IPv6-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
```
Si vous n'utilisez plus cet environnement, supprimez-le afin d'éviter des frais continus pour votre Compte AWS. Pour obtenir des instructions, consultez [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# WordPress tutoriel pour AWS Cloud9
Ce didacticiel vous permet de l'installer et de l'exécuter WordPress dans un environnement de AWS Cloud9 développement. WordPress est un système de gestion de contenu (CMS) open source largement utilisé pour la diffusion de contenu Web.
**Note**
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 Elastic Compute Cloud (Amazon EC2). Pour plus d’informations, consultez [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/).
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
+ **Vous disposez d'une instance up-to-date EC2 dotée de tous les derniers packages logiciels**. Dans la fenêtre du terminal AWS Cloud9 IDE, vous pouvez exécuter `yum update` avec l'`-y`option d'installer les mises à jour sans demander de confirmation. Si vous souhaitez examiner les mises à jour avant l’installation, vous pouvez omettre cette option.
```
sudo yum update -y
```
## Présentation de l'installation
L'installation WordPress sur l'instance EC2 de votre environnement implique les étapes suivantes :
1. Installation et configuration du serveur MariaDB, qui est une base de données relationnelle open source qui stocke des informations pour les installations WordPress
1. Installation et configuration WordPress, y compris la modification du fichier `wordpress.conf` de configuration
1. Configuration du serveur Apache qui héberge le WordPress site
1. Prévisualisation du contenu WordPress Web hébergé par le serveur Apache
## Etape 1 : Installation et configuration de MariaDB Server
1. Dans l' AWS Cloud9 IDE, choisissez **Window**, **New Terminal** et entrez les commandes suivantes pour installer et démarrer une installation de MariaDB Server :
```
sudo yum install -y mariadb-server
sudo systemctl start mariadb
```
1. Exécutez ensuite le script `mysql_secure_installation` pour améliorer la sécurité de votre installation de MariaDB Server.
Lorsque vous fournissez des réponses au script, appuyez sur **Entrée** à la première question afin de conserver le mot de passe root vide. Appuyez sur **n** pour `Set root password?` puis sur **y** pour chacune des autres options de sécurité.
```
mysql_secure_installation
```
1. Créez maintenant une table de base de données pour stocker WordPress des informations à l'aide du client MariaDB.
(Appuyez sur **Entrée** lorsque vous êtes invité à entrer votre mot de passe.)
```
sudo mysql -u root -p
MariaDB [(none)]> create database wp_test;
MariaDB [(none)]> grant all privileges on wp_test.* to root@localhost identified by ';'
```
1. Pour vous déconnecter du client MariaDB, exécutez la commande `exit`.
## Étape 2 : Installation et configuration WordPress
1. Dans la fenêtre du terminal de l'IDE, accédez au répertoire `environment`, puis créez les répertoires `config` et `wordpress`. Exécutez ensuite la commande `touch` pour créer un fichier, appelé `wordpress.conf` dans le répertoire `config` :
```
cd /home/ec2-user/environment
mkdir config wordpress
touch config/wordpress.conf
```
1. Utilisez l'éditeur IDE ou vim pour mettre à jour les informations `wordpress.conf` de configuration de l'hôte qui permettent au serveur Apache de diffuser du WordPress contenu :
```
# Ensure that Apache listens on port 80
Listen 8080
DocumentRoot "/var/www/wordpress"
ServerName www.example.org
# Other directives here
```
1. Exécutez maintenant les commandes suivantes pour récupérer le fichier d'archive requis et l'installer WordPress :
```
cd /home/ec2-user/environment
wget https://wordpress.org/latest.tar.gz
tar xvf latest.tar.gz
```
1. Exécutez la commande `touch` pour créer un fichier appelé `wp-config.php` dans le répertoire `environment/wordpress` :
```
touch wordpress/wp-config.php
```
1. Utilisez l'éditeur IDE ou vim pour mettre à jour `wp-config.php` et remplacer les exemples de données par votre configuration :
```
// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define( 'DB_NAME', 'wp_test' );
/** MySQL database username */
define( 'DB_USER', 'wp_user' );
/** MySQL database password */
define( 'DB_PASSWORD', 'YourSecurePassword' );
/** MySQL hostname */
define( 'DB_HOST', 'localhost' );
/** Database Charset to use in creating database tables. */
define( 'DB_CHARSET', 'utf8' );
/** The Database Collate type. Don't change this if in doubt. */
define( 'DB_COLLATE', '' );
define('FORCE_SSL', true);
if ($_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https') $_SERVER['HTTPS'] = 'on';
```
## Étape 3 : Configuration de votre serveur HTTP Apache
1. Dans la fenêtre du terminal AWS Cloud9 IDE, assurez-vous qu'Apache est installé :
```
httpd -v
```
Si le serveur Apache n'est pas installé, exécutez la commande suivante :
```
sudo yum install -y httpd
```
1. Accédez au répertoire `/etc/httpd/conf.d`, qui est l'emplacement des fichiers de configuration de l'hôte virtuel d'Apache. Ensuite, utilisez la commande `ln` pour lier le `wordpress.conf` que vous avez créé précédemment au répertoire de travail actuel (`/etc/httpd/conf.d`) :
```
cd /etc/httpd/conf.d
sudo ln -s /home/ec2-user/environment/config/wordpress.conf
```
1. Accédez maintenant au répertoire `/var/www`, qui est le dossier racine par défaut des serveurs Apache. Puis utilisez la commande `ln` pour lier le répertoire `wordpress` que vous avez créé précédemment au répertoire de travail actuel (`/var/www`) :
```
cd /var/www
sudo ln -s /home/ec2-user/environment/wordpress
```
1. Exécutez la commande `chmod` pour permettre au serveur Apache d'exécuter du contenu dans le sous-répertoire `wordpress` :
```
sudo chmod +x /home/ec2-user/
```
1. Redémarrez maintenant le serveur Apache pour lui permettre de détecter les nouvelles configurations :
```
sudo service httpd restart
```
## Étape 4 : prévisualisation du contenu WordPress Web
1. À l'aide AWS Cloud9 de l'IDE, créez un nouveau fichier appelé `index.html` dans le répertoire suivant : `environment/wordpress`
1. Ajoutez du texte au format HTML à `index.html`. Par exemple :
```
Hello World!
```
1. Dans la fenêtre **Environnement**, choisissez le `index.html` fichier, puis sélectionnez **Aperçu, Aperçu** **de l'application en cours d'exécution**.
La page web, qui affiche le *Hello World \$1*, apparaît dans l'onglet de prévisualisation de l'application. Pour afficher le contenu web dans votre navigateur préféré, choisissez **Ouvrir dans une nouvelle fenêtre**.
Si vous supprimez le `index.html` fichier et actualisez l'onglet d'aperçu de l'application, la page WordPress de configuration s'affiche.
## Gestion des erreurs de contenu mixte
Les navigateurs Web affichent des erreurs de contenu mixte pour un WordPress site s'il charge des scripts ou du contenu HTTPS et HTTP en même temps. Le libellé des messages d'erreur dépend du navigateur web que vous utilisez, mais vous êtes informé que votre connexion à un site n'est pas sécurisée ou n'est pas entièrement sécurisée. Et votre navigateur web bloque l'accès au contenu mixte.
**Important**
Par défaut, toutes les pages web auxquelles vous accédez dans l'onglet Prévisualisation de l'application de l'IDE AWS Cloud9 utilisent automatiquement le protocole HTTPS. Si l'URI d'une page comporte le protocole `http` non sécurisé, il est automatiquement remplacé par `https`. Et vous ne pouvez pas accéder au contenu non sécurisé en modifiant manuellement `https` pour revenir à `http`.
Pour obtenir des conseils sur la mise en œuvre du protocole HTTPS pour votre site Web, consultez la [WordPressdocumentation](https://wordpress.org/support/article/https-for-wordpress/).
# Tutoriel Java pour AWS Cloud9
**Important**
Si vous utilisez un environnement de AWS Cloud9 développement soutenu par une instance EC2 dotée de 2 Go de mémoire ou plus, nous vous recommandons d'activer le support Java amélioré. Cela permet d'accéder à des fonctions de productivité telles que la saisie semi-automatique du code, le linting pour les erreurs, les actions spécifiques au contexte et les options de débogage telles que les points d'arrêt et les étapes.
Pour de plus amples informations, veuillez consulter [Prise en charge renforcée pour le développement Java](enhanced-java.md).
Ce didacticiel vous permet d'exécuter du code Java dans un environnement de AWS Cloud9 développement.
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 et Amazon S3. Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Conditions préalables](#sample-java-prerequisites)
+ [Étape 1 : Installer les outils requis](#sample-java-install)
+ [Étape 2 : Ajouter du code](#sample-java-code)
+ [Étape 3 : Créer et exécuter le code](#sample-java-run)
+ [Étape 4 : Configuration pour utiliser le AWS SDK pour Java](#sample-java-sdk)
+ [Étape 5 : configurer la gestion des AWS informations d'identification dans votre environnement](#sample-java-sdk-creds)
+ [Étape 6 : ajouter le code du AWS SDK](#sample-java-sdk-code)
+ [Étape 7 : créer et exécuter le code du AWS SDK](#sample-java-sdk-run)
+ [Étape 8 : nettoyer](#sample-java-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Installer les outils requis
Au cours de cette étape, vous allez installer un ensemble d'outils de développement Java dans votre environnement de AWS Cloud9 développement. Si vous disposez déjà d'un ensemble d'outils de développement Java tels que le JDK Oracle ou OpenJDK installé dans votre environnement, vous pouvez passer directement à [Étape 2 : Ajouter du code](#sample-java-code). Cet exemple a été développé avec OpenJDK 8, que vous pouvez installer dans votre environnement en effectuant la procédure suivante.
1. Vérifiez si OpenJDK 8 est déjà installé. Pour ce faire, dans une session de terminal dans l' AWS Cloud9 IDE, exécutez la version en ligne de commande du Java Runner avec l'**`-version`**option. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window** (Fenêtre), **New Terminal** (Nouveau terminal).)
```
java -version
```
En fonction de la sortie de la commande précédente, exécutez l'une des actions suivantes :
+ Si la sortie indique que la commande `java` n'est pas trouvée, passez à l'étape 2 de la procédure pour installer OpenJDK 8.
+ Si la sortie contient des valeurs commençant par `Java(TM)``Java Runtime Environment`, `Java SE`, `J2SE` ou `Java2`, l'OpenJDK n'est pas installé ou n'est pas défini en tant qu'ensemble d'outils de développement Java par défaut. Continuez avec l'étape 2 de cette procédure pour installer OpenJDK 8, puis passez à l'utilisation d'OpenJDK 8.
+ Si la sortie contient des valeurs commençant par `java version 1.8` et `OpenJDK`, passez directement à [Étape 2 : Ajouter du code](#sample-java-code). OpenJDK 8 est installé correctement pour cet exemple.
+ Si la sortie contient une `java version` inférieure à `1.8` et que les valeurs commencent par `OpenJDK`, passez à l'étape 2 de cette procédure pour mettre à niveau la version OpenJDK installée vers OpenJDK 8.
1. Assurez-vous que les dernières mises à jour de sécurité et que les correctifs les plus récents sont installés. Pour ce faire, exécutez l'outil yum (pour Amazon Linux) ou l'outil apt (pour Ubuntu Server) avec la commande ** `update` **.
Pour Amazon Linux :
```
sudo yum -y update
```
Pour Ubuntu Server :
```
sudo apt update
```
1. Installez OpenJDK 8 : Pour ce faire, exécutez l'outil yum (pour Amazon Linux) ou l'outil apt (pour Ubuntu Server) avec la commande ** `install` **, en spécifiant le paquet OpenJDK 8.
Pour Amazon Linux :
```
sudo yum -y install java-1.8.0-openjdk-devel
```
Pour Ubuntu Server :
```
sudo apt install -y openjdk-8-jdk
```
Pour plus d'informations, consultez la section [Procédure pour télécharger et installer les packages OpenJDK préintégrés](https://openjdk.org/install/) sur le site web OpenJDK.
1. Basculez ou mettez à niveau le jeu d'outils de développement Java par défaut vers OpenJDK 8. Pour ce faire, exécutez la commande ** `update-alternatives` ** avec l'option ** `--config` **. Exécutez cette commande deux fois pour basculer ou mettre à niveau les versions de ligne de commande de l'exécuteur et compilateur Java.
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
À chaque invite, tapez le numéro de sélection d'OpenJDK 8 (celui qui contient `java-1.8`).
1. Vérifiez que les versions de ligne de commande de l'exécuteur et compilateur Java utilisent OpenJDK 8. Pour ce faire, exécutez les versions de ligne de commande de l'exécuteur et compilateur Java avec l'option `-version`.
```
java -version
javac -version
```
Si OpenJDK 8 est installé et défini correctement, la sortie de la version de l'exécuteur Java contient une valeur commençant par `openjdk version 1.8` et la sortie de la version du compilateur Java commence par la valeur `javac 1.8`.
## Étape 2 : Ajouter du code
Dans l' AWS Cloud9 IDE, créez un fichier avec le code suivant, puis enregistrez le fichier sous son nom`hello.java`. (Pour créer un fichier, dans la barre de menus, choisissez **Fichier**, **Nouveau fichier**. Pour l'enregistrer, choisissez **Fichier**, **Enregistrer**.)
```
public class hello {
public static void main(String []args) {
System.out.println("Hello, World!");
System.out.println("The sum of 2 and 3 is 5.");
int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]);
System.out.format("The sum of %s and %s is %s.\n",
args[0], args[1], Integer.toString(sum));
}
}
```
## Étape 3 : Créer et exécuter le code
1. Utilisez la version de ligne de commande du compilateur Java pour compiler le fichier `hello.java` en un fichier `hello.class`. Pour ce faire, à l'aide du terminal de l' AWS Cloud9 IDE, depuis le même répertoire que le `hello.java` fichier, exécutez le compilateur Java en spécifiant le `hello.java` fichier.
```
javac hello.java
```
1. Utilisez la version de ligne de commande de l'exécuteur Java pour exécuter le fichier `hello.class`. Pour ce faire, dans le même répertoire que le fichier `hello.class`, exécutez l'exécuteur Java, en spécifiant le nom de la classe `hello` qui a été déclarée dans le fichier `hello.java`, avec deux nombres entiers à ajouter (par exemple, `5` et `9`).
```
java hello 5 9
```
1. Comparez votre sortie.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Étape 4 : Configuration pour utiliser le AWS SDK pour Java
Vous pouvez améliorer cet exemple AWS SDK pour Java pour créer un compartiment Amazon S3, répertorier vos compartiments disponibles, puis supprimer le compartiment que vous venez de créer.
Dans cette étape, vous installez [Apache Maven](https://maven.apache.org/) ou [Gradle](https://gradle.org/) dans votre environnement. Maven et Gradle sont des systèmes courants d'automatisation de build qui peuvent être utilisés avec les projets Java. Une fois que vous avez installé Maven ou Gradle, vous l'utilisez pour générer un nouveau projet Java. Dans ce nouveau projet, vous ajoutez une référence au kit AWS SDK pour Java. Cela AWS SDK pour Java constitue un moyen pratique d'interagir avec des AWS services tels qu'Amazon S3, à partir de votre code Java.
**Topics**
+ [Configuration avec Maven](#sample-java-sdk-maven)
+ [Configuration avec Gradle](#sample-java-sdk-gradle)
### Configuration avec Maven
1. Installez Maven dans votre environnement. Pour voir si Maven est déjà installé, à l'aide du terminal de l' AWS Cloud9 IDE, exécutez Maven avec l'**`-version`**option.
```
mvn -version
```
En cas de réussite, la sortie contient le numéro de version Maven. Si Maven est déjà installé, passez directement à l'étape 4 de cette procédure pour utiliser Maven et générer un nouveau projet Java dans votre environnement.
1. Installez Maven en utilisant le terminal pour exécuter les commandes suivantes.
Pour Amazon Linux, les commandes suivantes obtiennent des informations sur le répertoire du paquet où Maven est stocké, puis utilisent ces informations pour installer Maven.
```
sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo
sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo
sudo yum install -y apache-maven
```
Pour plus d'informations sur les commandes précédentes, consultez le [référentiel EPEL (Extra Packages for Enterprise Linux)](https://docs.fedoraproject.org/en-US/epel/) sur le site web Wiki de Fedora Project.
Pour Ubuntu Server, exécutez la commande suivante à la place.
```
sudo apt install -y maven
```
1. Vérifiez l'installation en exécutant Maven avec l'option ** `-version` **.
```
mvn -version
```
1. Utilisez Maven pour générer un nouveau projet Java. Pour ce faire, utilisez le terminal pour exécuter la commande suivante à partir du répertoire dans lequel vous voulez que Maven génère le projet (par exemple, le répertoire racine de votre environnement).
```
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```
La commande précédente crée la structure de répertoire suivante pour le projet de votre environnement.
```
my-app
|- src
| `- main
| `- java
| `- com
| `- mycompany
| `- app
| `-App.java
|- test
| `- java
| `- com
| `- mycompany
| `- app
| `- AppTest.java
`- pom.xml
```
Pour plus d'informations sur la structure de répertoire précédente, consultez [Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/) et [Introduction to the Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) sur le site web Apache Maven Project.
1. Modifiez le fichier POM (Project Object Model) du projet. (Un fichier POM définit les paramètres d'un projet Maven.) Pour ce faire, depuis la fenêtre **Environment (Environnement)**, ouvrez le fichier `my-app/pom.xml`. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `pom.xml`.
```
4.0.0
com.mycompany.app
my-app
jar
1.0-SNAPSHOT
org.apache.maven.plugins
maven-assembly-plugin
3.6.0
jar-with-dependencies
com.mycompany.app.App
package
single
junit
junit
3.8.1
test
com.amazonaws
aws-java-sdk
1.11.330
```
Le fichier POM précédent inclut les paramètres de projet qui spécifient les déclarations telles que les suivantes :
+ Le paramètre `artifactid` de `my-app` définit le nom du répertoire racine du projet, et le paramètre `group-id` de `com.mycompany.app` définit la structure du sous-répertoire `com/mycompany/app` et la déclaration `package` des fichiers `App.Java` et `AppTest.java`.
+ Le paramètre `artifactId` de `my-app`, avec le paramètre `packaging` de `jar`, le paramètre `version` de `1.0-SNAPSHOT` et le paramètre `descriptorRef` de `jar-with-dependencies` définissent le nom `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar` du fichier JAR de sortie.
+ La section `plugin` déclare qu'un seul fichier JAR, qui comprend toutes les dépendances, sera créé.
+ La `dependency` section contenant le `groupId` paramètre de `com.amazon.aws` et le `artifactId` paramètre de `aws-java-sdk` inclut les fichiers de AWS SDK pour Java bibliothèque. La version du kit AWS SDK pour Java à utiliser est déclarée par le paramètre `version`. Pour utiliser une autre version, remplacez ce numéro de version.
Passez directement à [Étape 5 : configurer la gestion des AWS informations d'identification dans votre environnement](#sample-java-sdk-creds).
### Configuration avec Gradle
1. Installez Gradle dans votre environnement. Pour voir si Gradle est déjà installé, à l'aide du terminal de l' AWS Cloud9 IDE, exécutez Gradle avec l'**`-version`**option.
```
gradle -version
```
En cas de réussite, la sortie contient le numéro de version Gradle. Si Gradle est déjà installé, passez directement à l'étape 4 de cette procédure pour utiliser Gradle et générer un nouveau projet Java dans votre environnement.
1. Installez Gradle en utilisant le terminal pour exécuter les commandes suivantes. Ces commandes installent et exécutent outil SDKMAN\$1, puis utilisent SDKMAN\$1 pour installer la dernière version de Gradle.
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
Pour plus d'informations sur les commandes précédentes, consultez [Installation](https://sdkman.io/install) sur le site Web SDKMAN\$1 et [Installer avec un gestionnaire de package](https://gradle.org/install/#with-a-package-manager) sur le site Web Gradle.
1. Vérifiez l'installation en exécutant Gradle avec l'option ** `-version` **.
```
gradle -version
```
1. Utilisez Gradle pour générer un nouveau projet Java dans votre environnement. Pour ce faire, utilisez le terminal pour exécuter les commandes suivantes pour créer un répertoire pour le projet, puis basculez vers ce répertoire.
```
mkdir my-app
cd my-app
```
1. Exécutez la commande suivante pour que Gradle génère un nouveau projet d'application Java dans le répertoire `my-app` de votre environnement.
```
gradle init --type java-application
```
La commande précédente crée la structure de répertoire suivante pour le projet de votre environnement.
```
my-app
|- .gradle
| `- (various supporting project folders and files)
|- gradle
| `- (various supporting project folders and files)
|- src
| |- main
| | `- java
| | `- App.java
| `- test
| `- java
| `- AppTest.java
|- build.gradle
|- gradlew
|- gradlew.bat
`- settings.gradle
```
1. Modifiez le fichier `AppTest.java` pour le projet. (Si vous ne le faites pas, le projet risque de ne pas être généré ou de ne pas s'exécuter comme prévu). Pour ce faire, depuis la fenêtre **Environment (Environnement)**, ouvrez le fichier `my-app/src/test/java/AppTest.java`. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `AppTest.java`.
```
import org.junit.Test;
import static org.junit.Assert.*;
public class AppTest {
@Test public void testAppExists () {
try {
Class.forName("com.mycompany.app.App");
} catch (ClassNotFoundException e) {
fail("Should have a class named App.");
}
}
}
```
1. Modifiez le fichier `build.gradle` pour le projet. (Un fichier `build.gradle` définit les paramètres d'un projet Maven.) Pour ce faire, depuis la fenêtre **Environment (Environnement)**, ouvrez le fichier `my-app/build.gradle`. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `build.gradle`.
```
apply plugin: 'java'
apply plugin: 'application'
repositories {
jcenter()
mavenCentral()
}
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
}
}
apply plugin: "io.spring.dependency-management"
dependencyManagement {
imports {
mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330'
}
}
dependencies {
compile 'com.amazonaws:aws-java-sdk-s3'
testCompile group: 'junit', name: 'junit', version: '4.12'
}
run {
if (project.hasProperty("appArgs")) {
args Eval.me(appArgs)
}
}
mainClassName = 'App'
```
Le fichier `build.gradle` précédent inclut les paramètres de projet qui spécifient les déclarations telles que les suivantes :
+ Le `io.spring.dependency-management` plugin est utilisé pour importer le AWS SDK pour Java Maven Bill of Materials (BOM) afin de gérer les AWS SDK pour Java dépendances du projet. `classpath`déclare la version à utiliser. Pour utiliser une autre version, remplacez ce numéro de version.
+ `com.amazonaws:aws-java-sdk-s3` inclut la partie Amazon S3 de la bibliothèque de fichiers de AWS SDK pour Java . `mavenBom` déclare la version à utiliser. Pour utiliser une autre version, remplacez ce numéro de version.
## Étape 5 : configurer la gestion des AWS informations d'identification dans votre environnement
Chaque fois que vous utilisez le AWS SDK pour Java pour appeler un AWS service, vous devez fournir un ensemble d' AWS informations d'identification avec l'appel. Ces informations d'identification déterminent s'il AWS SDK pour Java dispose des autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue.
Au cours de cette étape, vous allez stocker vos informations d'identification dans l'environnement. Pour ce faire, suivez les instructions de la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique.
Pour plus d'informations, consultez la section [Configurer les informations d'identification AWS et la région pour le développement](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) dans le *Guide du développeur AWS SDK pour Java *.
## Étape 6 : ajouter le code du AWS SDK
Au cours de cette étape, vous allez ajouter du code supplémentaire pour interagir avec Amazon S3, créer un compartiment, répertorier les compartiments disponibles, puis supprimer le compartiment que vous venez de créer.
Dans la fenêtre **Environment (Environnement)**, ouvrez le fichier `my-app/src/main/java/com/mycompany/app/App.java` pour Maven ou le fichier `my-app/src/main/java/App.java` pour Gradle. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `App.java`.
```
package com.mycompany.app;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.Bucket;
import com.amazonaws.services.s3.model.CreateBucketRequest;
import java.util.List;
public class App {
private static AmazonS3 s3;
public static void main(String[] args) {
if (args.length < 2) {
System.out.format("Usage: \n" +
"Example: my-test-bucket us-east-2\n");
return;
}
String bucket_name = args[0];
String region = args[1];
s3 = AmazonS3ClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(region)
.build();
// List current buckets.
ListMyBuckets();
// Create the bucket.
if (s3.doesBucketExistV2(bucket_name)) {
System.out.format("\nCannot create the bucket. \n" +
"A bucket named '%s' already exists.", bucket_name);
return;
} else {
try {
System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name);
s3.createBucket(new CreateBucketRequest(bucket_name, region));
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
}
// Confirm that the bucket was created.
ListMyBuckets();
// Delete the bucket.
try {
System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name);
s3.deleteBucket(bucket_name);
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
// Confirm that the bucket was deleted.
ListMyBuckets();
}
private static void ListMyBuckets() {
List buckets = s3.listBuckets();
System.out.println("My buckets now are:");
for (Bucket b : buckets) {
System.out.println(b.getName());
}
}
}
```
## Étape 7 : créer et exécuter le code du AWS SDK
Pour exécuter le code de l'étape précédente, exécutez les commandes suivantes depuis le terminal. Ces commandes utilisent Maven ou Gradle pour créer un fichier exécutable JAR pour le projet, puis l'exécuteur Java pour exécuter le fichier JAR. Le JAR s'exécute avec le nom du compartiment à créer dans Amazon S3 (par exemple,`my-test-bucket`) et l'ID de la AWS région dans laquelle le compartiment doit être créé en entrée (par exemple,`us-east-2`).
Pour Maven, exécutez les commandes suivantes.
```
cd my-app
mvn package
java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2
```
Pour Gradle, exécutez les commandes suivantes.
```
gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
```
Comparez le résultat obtenu à la sortie suivante.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Étape 8 : nettoyer
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, veuillez consulter [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# Tutoriel C\$1\$1 pour AWS Cloud9
Ce didacticiel vous permet d'exécuter du code C\$1\$1 dans un environnement de AWS Cloud9 développement. Le code utilise également les ressources fournies par [AWS SDK pour C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/welcome.html), une bibliothèque open source modularisée, multiplateforme, que vous pouvez utiliser pour vous connecter à Amazon Web Services.
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 et Amazon S3. Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Conditions préalables](#sample-cplusplus-prereqs)
+ [Étape 1 : Installer g\$1\$1 et les paquets de développement requis](#sample-cplusplus-install)
+ [Étape 2 : Installation CMake](#install-cmake)
+ [Étape 3 : Obtenir et générer le kit SDK for C\$1\$1](#install-cmake)
+ [Étape 4 : Création de fichiers C\$1\$1 et CMake listes](#sample-cplusplus-sdk-code)
+ [Étape 5 : Créer et exécuter le code C\$1\$1](#build-and-run-cpp)
+ [Étape 6 : Nettoyer](#sample-cplusplus-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Installer g\$1\$1 et les paquets de développement requis
Pour créer et exécuter une application C \$1\$1, vous avez besoin d'un utilitaire tel que `g++`, qui est un compilateur C \$1\$1 fourni par la [GNU Compiler Collection (GCC)](https://gcc.gnu.org/).
Vous devez également ajouter des fichiers d'en-tête (paquets `-dev`) pour `libcurl`, `libopenssl`, `libuuid`, `zlib` et éventuellement `libpulse` pour la prise en charge d'Amazon Polly.
Le processus d'installation des outils de développement varie légèrement selon que vous utilisez une instance Amazon Linux/Amazon Linux 2 ou une instance Ubuntu.
------
#### [ Amazon Linux-based systems ]
Vous pouvez vérifier si vous l'avez déjà `gcc` installé en exécutant la commande suivante dans le AWS Cloud9 terminal :
```
g++ --version
```
Si `g++` n'est pas installé, vous pouvez facilement l'installer dans le groupe de paquets appelé « Outils de développement ». Ces outils sont ajoutés à une instance avec l'outil de commande `yum groupinstall` :
```
sudo yum groupinstall "Development Tools"
```
Exécutez `g++ --version` à nouveau pour confirmer que le compilateur a été installé.
Installez maintenant les paquets pour les bibliothèques requises à l'aide du gestionnaire de paquets de votre système :
```
sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
```
------
#### [ Ubuntu-based systems ]
Vous pouvez vérifier si vous l'avez déjà `gcc` installé en exécutant la commande suivante dans le AWS Cloud9 terminal :
```
g++ --version
```
Si gcc n'est pas installé, vous pouvez l'installer sur un système Ubuntu en exécutant les commandes suivantes :
```
sudo apt update
sudo apt install build-essential
sudo apt-get install manpages-dev
```
Exécutez `g++ --version` à nouveau pour confirmer que le compilateur a été installé.
Installez maintenant les paquets pour les bibliothèques requises à l'aide du gestionnaire de paquets de votre système :
```
sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
```
------
## Étape 2 : Installation CMake
Vous devez installer l'outil `cmake`, qui automatise le processus de création de fichiers exécutables à partir du code source.
1. Dans la fenêtre de terminal de l'IDE, exécutez la commande suivante pour obtenir l'archive requise :
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
1. Extrayez les fichiers de l'archive et accédez au répertoire contenant les fichiers décompressés :
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
1. Ensuite, exécutez un script d'amorçage et installez `cmake` en exécutant les commandes suivantes :
```
./bootstrap
make
sudo make install
```
1. Vérifiez que vous avez installé l'outil en exécutant la commande suivante :
```
cmake --version
```
## Étape 3 : Obtenir et générer le kit SDK for C\$1\$1
Pour configurer le AWS SDK pour C\$1\$1, vous pouvez soit le créer vous-même directement à partir de la source, soit télécharger les bibliothèques à l'aide d'un gestionnaire de packages. Vous trouverez des informations détaillées sur les options disponibles dans [Getting Started Using the AWS SDK for](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/getting-started.html) C\$1\$1 dans *AWS SDK pour C\$1\$1 le manuel du développeur*.
Cet exemple illustre l'utilisation de `git` pour cloner le code source du kit SDK et de `cmake` pour générer le kit SDK for C\$1\$1.
1. Clonez le référentiel distant et obtenez tous les sous-modules git récursivement pour votre environnement AWS Cloud9 en exécutant la commande suivante dans le terminal :
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
1. Accédez au nouveau `aws-sdk-cpp` répertoire, créez un sous-répertoire dans lequel intégrer le AWS SDK for C\$1\$1, puis naviguez jusqu'à celui-ci :
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
1.
**Note**
Pour gagner du temps, cette étape génère uniquement la partie Amazon S3 du AWS SDK pour C\$1\$1. Si vous souhaitez créer le kit SDK complet, omettez le `-DBUILD_ONLY=s3` dans la commande `cmake`.
La compilation du kit SDK complet pour C\$1\$1 peut prendre une heure, en fonction des ressources de calcul disponibles pour votre instance Amazon EC2 ou votre propre serveur.
Utilisez `cmake` pour générer la partie Amazon S3 du kit SDK pour C\$1\$1 dans le répertoire `sdk_build` en exécutant la commande suivante :
```
cmake .. -DBUILD_ONLY=s3
```
1. Maintenant, exécutez la commande `make install` afin que le kit SDK compilé soit accessible :
```
sudo make install
cd ..
```
## Étape 4 : Création de fichiers C\$1\$1 et CMake listes
Au cours de cette étape, vous créez un fichier `C++` qui permet aux utilisateurs du projet d'interagir avec les compartiments Amazon S3.
Vous créez également un fichier `CMakeLists.txt` qui fournit des instructions utilisées par `cmake` pour créer votre bibliothèque C \$1\$1.
1. Dans l' AWS Cloud9 IDE, créez un fichier avec ce contenu et enregistrez-le avec le nom `s3-demo.cpp` à la racine (`/`) de votre environnement.
```
#include
#include
#include
#include
#include
#include
#include
// Look for a bucket among all currently available Amazon S3 buckets.
bool FindTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
Aws::S3::Model::ListBucketsOutcome outcome = s3Client.ListBuckets();
if (outcome.IsSuccess()) {
std::cout << "Looking for a bucket named '" << bucketName << "'..."
<< std::endl << std::endl;
Aws::Vector bucket_list =
outcome.GetResult().GetBuckets();
for (Aws::S3::Model::Bucket const &bucket: bucket_list) {
if (bucket.GetName() == bucketName) {
std::cout << "Found the bucket." << std::endl << std::endl;
return true;
}
}
std::cout << "Could not find the bucket." << std::endl << std::endl;
} else {
std::cerr << "listBuckets error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Create an Amazon S3 bucket.
bool CreateTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName,
const Aws::String ®ion) {
std::cout << "Creating a bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::CreateBucketRequest request;
request.SetBucket(bucketName);
if (region != "us-east-1") {
Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
createBucketConfig.SetLocationConstraint(
Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
region));
request.SetCreateBucketConfiguration(createBucketConfig);
}
Aws::S3::Model::CreateBucketOutcome outcome =
s3Client.CreateBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket created." << std::endl << std::endl;
} else {
std::cerr << "createBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Delete an existing Amazon S3 bucket.
bool DeleteTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
std::cout << "Deleting the bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::DeleteBucketRequest request;
request.SetBucket(bucketName);
Aws::S3::Model::DeleteBucketOutcome outcome =
s3Client.DeleteBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket deleted." << std::endl << std::endl;
} else {
std::cerr << "deleteBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
#ifndef EXCLUDE_MAIN_FUNCTION
// Create an S3 bucket and then delete it.
// Before and after creating the bucket, and again after deleting the bucket,
// try to determine whether that bucket still exists.
int main(int argc, char *argv[]) {
if (argc < 3) {
std::cout << "Usage: s3-demo " << std::endl
<< "Example: s3-demo my-bucket us-east-1" << std::endl;
return 1;
}
Aws::SDKOptions options;
Aws::InitAPI(options);
{
Aws::String bucketName = argv[1];
Aws::String region = argv[2];
Aws::Client::ClientConfiguration config;
config.region = region;
Aws::S3::S3Client s3Client(config);
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!CreateTheBucket(s3Client, bucketName, region)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!DeleteTheBucket(s3Client, bucketName)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
}
Aws::ShutdownAPI(options);
return 0;
}
#endif // EXCLUDE_MAIN_FUNCTION
```
1. Créez un second fichier avec ce contenu et enregistrez-le sous le nom `CMakeLists.txt` à la racine (`/`) de votre environnement. Ce fichier vous permet de créer votre code dans un fichier exécutable.
```
# A minimal CMakeLists.txt file for the AWS SDK for C++.
# The minimum version of CMake that will work.
cmake_minimum_required(VERSION 2.8)
# The project name.
project(s3-demo)
# Locate the AWS SDK for C++ package.
set(AWSSDK_ROOT_DIR, "/usr/local/")
set(BUILD_SHARED_LIBS ON)
find_package(AWSSDK REQUIRED COMPONENTS s3)
# The executable name and its source files.
add_executable(s3-demo s3-demo.cpp)
# The libraries used by your executable.
target_link_libraries(s3-demo ${AWSSDK_LINK_LIBRARIES})
```
## Étape 5 : Créer et exécuter le code C\$1\$1
1. Dans le répertoire racine de votre environnement dans lequel vous avez enregistré `s3-demo.cpp` et `CMakeLists.txt`, exécutez `cmake` pour créer votre projet :
```
cmake .
make
```
1. À présent, vous pouvez exécuter votre programme à partir de la ligne de commande. Dans la commande suivante, remplacez `my-unique-bucket-name` par un nom unique pour le compartiment Amazon S3 et, si nécessaire, remplacez `us-east-1` par l'identifiant d'une autre région AWS dans laquelle vous souhaitez créer un compartiment.
```
./s3-demo my-unique-bucket-name us-east-1
```
Si le programme s'exécute correctement, vous obtenez une sortie similaire à ce qui suit :
```
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
Creating a bucket named 'my-unique-bucket-name'...
Bucket created.
Looking for a bucket named 'my-unique-bucket-name'...
Found the bucket.
Deleting the bucket named 'my-unique-bucket-name'...
Bucket deleted.
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
```
## Étape 6 : Nettoyer
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, supprimez l'environnement. Pour obtenir des instructions, veuillez consulter [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# Tutoriel Python pour AWS Cloud9
Ce didacticiel explique comment exécuter du code Python dans un environnement de AWS Cloud9 développement.
Le fait de suivre ce didacticiel peut entraîner des frais sur votre AWS compte. Il peut s'agir de frais pour des services tels qu’Amazon Elastic Compute Cloud (Amazon EC2) et Amazon Simple Storage Service (Amazon S3). Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Conditions préalables](#sample-python-prereqs)
+ [Étape 1 : Installer Python](#sample-python-install)
+ [Étape 2 : Ajouter du code](#sample-python-code)
+ [Étape 3 : Exécuter le code](#sample-python-run)
+ [Étape 4 : Installation et configuration du AWS SDK pour Python (Boto3)](#sample-python-sdk)
+ [Étape 5 : ajouter le code du AWS SDK](#sample-python-sdk-code)
+ [Étape 6 : Exécuter le code du AWS SDK](#sample-python-sdk-run)
+ [Étape 7 : nettoyer](#sample-python-clean-up)
## Conditions préalables
Avant d'utiliser ce tutoriel, vérifiez que vous respectez les conditions requises suivantes :
+ **Vous disposez d'un environnement AWS Cloud9 de développement EC2**
Cet exemple suppose que vous disposez d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Consultez [Création d'un EC2 environnement](create-environment-main.md) pour plus de détails.
Si vous avez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de ce tutoriel.
+ **Vous avez ouvert l' AWS Cloud9 IDE pour cet environnement**
Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Consultez [Ouvrir un environnement dans AWS Cloud9](open-environment.md) pour plus de détails.
## Étape 1 : Installer Python
1. Dans une session de terminal dans l' AWS Cloud9 IDE, vérifiez si Python est déjà installé en exécutant la **`python --version`**commande. (Pour démarrer une nouvelle session de terminal, dans la barre de menus, choisissez **Window (Fenêtre)**, **New Terminal (Nouveau terminal)**.) Si Python est installé, passez directement à [Étape 2 : Ajouter du code](#sample-python-code).
1. Exécutez la commande ** `yum update`** (pour Amazon Linux) ou la commande **`apt update`** (pour Ubuntu Server) afin d'être sûr que les mises à jour de sécurité et les correctifs les plus récents sont installés.
Pour Amazon Linux :
```
sudo yum -y update
```
Pour Ubuntu Server :
```
sudo apt update
```
1. Installez Python en exécutant la commande ** `install` **.
Pour Amazon Linux :
```
sudo yum -y install python3
```
Pour Ubuntu Server :
```
sudo apt-get install python3
```
## Étape 2 : Ajouter du code
Dans l' AWS Cloud9 IDE, créez un fichier avec le contenu suivant et enregistrez le fichier sous son nom`hello.py`. (Pour créer un fichier, dans la barre de menus, choisissez **Fichier**, **Nouveau fichier**. Pour l'enregistrer, choisissez **Fichier**, **Enregistrer**.)
```
import sys
print('Hello, World!')
print('The sum of 2 and 3 is 5.')
sum = int(sys.argv[1]) + int(sys.argv[2])
print('The sum of {0} and {1} is {2}.'.format(sys.argv[1], sys.argv[2], sum))
```
## Étape 3 : Exécuter le code
1. Dans l' AWS Cloud9 IDE, dans la barre de menu, choisissez **Run, Run** **Configurations**, **New Run Configuration**.
1. Dans l'onglet **[Nouveau] - Arrêté**, entrez `hello.py 5 9` dans **Commande**. Dans le code, `5` représente `sys.argv[1]` et `9` représente `sys.argv[2]`.
1. Choisissez **Run (Exécuter)** et comparez la sortie.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
1. Par défaut, sélectionne AWS Cloud9 automatiquement un runner pour votre code. Pour changer l’exécuteur, choisissez **Runner (Exécuteur)**, puis **Python 2** ou **Python 3**.
**Note**
Vous pouvez créer des exécuteurs personnalisés pour des versions spécifiques de Python. Pour en savoir plus, consultez [Création d'un générateur ou d'un exécuteur](build-run-debug.md#build-run-debug-create-builder-runner).
## Étape 4 : Installation et configuration du AWS SDK pour Python (Boto3)
AWS SDK pour Python (Boto3) Cela vous permet d'utiliser du code Python pour interagir avec des AWS services tels qu'Amazon S3. Par exemple, vous pouvez utiliser le kit SDK pour créer un compartiment Amazon S3, répertorier vos compartiments disponibles, puis supprimer le compartiment que vous venez de créer.
### Installation de pip
Dans l' AWS Cloud9 IDE, vérifiez si la version active de Python `pip` est déjà installée en exécutant la **`python -m pip --version`**commande. Si `pip` est installé, passez à la section suivante.
Pour installer `pip`, exécutez les commandes suivantes. Étant donné que sudo se trouve dans un environnement différent de celui de votre utilisateur, vous devez spécifier la version de Python à utiliser si elle diffère de la version alias actuelle.
```
curl -O https://bootstrap.pypa.io/get-pip.py # Get the install script.
sudo python3 get-pip.py # Install pip for Python 3.
python -m pip --version # Verify pip is installed.
rm get-pip.py # Delete the install script.
```
Pour plus d’informations, consultez [Installation](https://pip.pypa.io/en/stable/installing/) sur le site Web `pip`.
### Installez le AWS SDK pour Python (Boto3)
Après l'installation`pip`, installez-le AWS SDK pour Python (Boto3) en exécutant la **`pip install`**commande.
```
sudo python3 -m pip install boto3 # Install boto3 for Python 3.
python -m pip show boto3 # Verify boto3 is installed for the current version of Python.
```
Pour plus d'informations, consultez la section « Installation » du [Quickstart](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) dans le AWS SDK pour Python (Boto3).
### Configurer les informations d'identification dans votre environnement
Chaque fois que vous utilisez le AWS SDK pour Python (Boto3) pour appeler un AWS service, vous devez fournir un ensemble d'informations d'identification avec l'appel. Ces informations d'identification déterminent si le kit SDK dispose des autorisations nécessaires pour effectuer l'appel. Si les informations d'identification ne couvrent pas les autorisations nécessaires, l'appel échoue.
Pour stocker vos informations d'identification au sein de l'environnement, suivez les instructions fournies dans la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique.
Pour plus d'informations, consultez les informations relatives aux [informations d'identification](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html) dans le AWS SDK pour Python (Boto3).
## Étape 5 : ajouter le code du AWS SDK
Ajoutez un code qui utilise Amazon S3 pour créer un compartiment, répertoriez vos compartiments disponibles et supprimez éventuellement le compartiment que vous venez de créer.
Dans l' AWS Cloud9 IDE, créez un fichier avec le contenu suivant et enregistrez le fichier sous son nom`s3.py`.
```
import sys
import boto3
from botocore.exceptions import ClientError
def list_my_buckets(s3_resource):
print("Buckets:\n\t", *[b.name for b in s3_resource.buckets.all()], sep="\n\t")
def create_and_delete_my_bucket(s3_resource, bucket_name, keep_bucket):
list_my_buckets(s3_resource)
try:
print("\nCreating new bucket:", bucket_name)
bucket = s3_resource.create_bucket(
Bucket=bucket_name,
CreateBucketConfiguration={
"LocationConstraint": s3_resource.meta.client.meta.region_name
},
)
except ClientError as e:
print(
f"Couldn't create a bucket for the demo. Here's why: "
f"{e.response['Error']['Message']}"
)
raise
bucket.wait_until_exists()
list_my_buckets(s3_resource)
if not keep_bucket:
print("\nDeleting bucket:", bucket.name)
bucket.delete()
bucket.wait_until_not_exists()
list_my_buckets(s3_resource)
else:
print("\nKeeping bucket:", bucket.name)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("bucket_name", help="The name of the bucket to create.")
parser.add_argument("region", help="The region in which to create your bucket.")
parser.add_argument(
"--keep_bucket",
help="Keeps the created bucket. When not "
"specified, the bucket is deleted "
"at the end of the demo.",
action="store_true",
)
args = parser.parse_args()
s3_resource = (
boto3.resource("s3", region_name=args.region)
if args.region
else boto3.resource("s3")
)
try:
create_and_delete_my_bucket(s3_resource, args.bucket_name, args.keep_bucket)
except ClientError:
print("Exiting the demo.")
if __name__ == "__main__":
main()
```
## Étape 6 : Exécuter le code du AWS SDK
1. Dans la barre de menus, choisissez **Exécuter**, **Configurations d'exécution**, **Nouvelle configuration d'exécution**.
1. Dans **Command**`s3.py my-test-bucket us-west-2`, entrez `my-test-bucket` le nom du bucket à créer et `us-west-2` l'ID de la AWS région dans laquelle votre bucket est créé. Par défaut, votre compartiment est supprimé avant la fin du script. Pour conserver votre compartiment, ajoutez `--keep_bucket` à votre commande. Pour obtenir la liste des AWS régions IDs, consultez [Amazon Simple Storage Service Endpoints and Quotas](https://docs.aws.amazon.com/general/latest/gr/s3.html) dans le *Références générales AWS*.
**Note**
Les noms des compartiments Amazon S3 doivent être uniques pour l'ensemble de votre compte AWS, et pas uniquement pour ce qui est de votre AWS compte.
1. Choisissez le bouton **Run (Exécuter)** et comparez la sortie.
```
Buckets:
a-pre-existing-bucket
Creating new bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
my-test-bucket
Deleting bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
```
## Étape 7 : nettoyer
Pour éviter que des frais ne soient facturés à votre AWS compte une fois que vous aurez terminé ce didacticiel, supprimez l' AWS Cloud9 environnement. Pour obtenir des instructions, veuillez consulter [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# Tutoriel .NET pour AWS Cloud9
Ce didacticiel vous permet d'exécuter du code .NET dans un environnement de AWS Cloud9 développement.
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 et Amazon S3. Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Conditions préalables](#sample-dotnetcore-prereqs)
+ [Étape 1 : Installer les outils requis](#sample-dotnetcore-setup)
+ [Étape 2 (facultative) : Installer l'extension .NET CLI pour les fonctions Lambda](#sample-dotnetcore-lambda)
+ [Étape 3 : Création d'un projet d'application de console .NET](#sample-dotnetcore-app)
+ [Étape 4 : Ajouter du code](#sample-dotnetcore-code)
+ [Étape 5 : Créer et exécuter le code](#sample-dotnetcore-run)
+ [Étape 6 : créer et configurer un projet d'application de console .NET qui utilise AWS SDK pour .NET](#sample-dotnetcore-sdk)
+ [Étape 7 : ajouter le code du AWS SDK](#sample-dotnetcore-sdk-code)
+ [Étape 8 : créer et exécuter le code du AWS SDK](#sample-dotnetcore-sdk-run)
+ [Étape 9 : nettoyer](#sample-dotnetcore-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Installer les outils requis
Au cours de cette étape, vous allez installer le SDK .NET dans votre environnement, qui est nécessaire pour exécuter cet exemple.
1. Vérifiez si la dernière version du SDK .NET est déjà installée dans votre environnement. Pour ce faire, dans une session de terminal dans l' AWS Cloud9 IDE, exécutez l'interface de ligne de commande (CLI) .NET Core avec l'**`--version`**option.
```
dotnet --version
```
Si la version des outils de ligne de commande .NET s'affiche, et s'il s'agit de la version 2.0 ou ultérieure, passez directement à [Étape 3 : Création d'un projet d'application de console .NET](#sample-dotnetcore-app). Si la version est inférieure à 2.0 ou si une erreur telle qu'elle `bash: dotnet: command not found` s'affiche, poursuivez l'installation du SDK .NET.
1. Pour Amazon Linux, lors d'une session de terminal dans l' AWS Cloud9 IDE, exécutez les commandes suivantes pour vous assurer que les dernières mises à jour de sécurité et corrections de bogues sont installées, et pour installer le `libunwind` package dont le SDK .NET a besoin. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Fenêtre, nouveau terminal)**.)
```
sudo yum -y update
sudo yum -y install libunwind
```
Pour Ubuntu Server, dans une session de terminal dans l' AWS Cloud9 IDE, exécutez la commande suivante pour vous assurer que les dernières mises à jour de sécurité et corrections de bogues sont installées. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Fenêtre, nouveau terminal)**.)
```
sudo apt -y update
```
1. Téléchargez le script d'installation du SDK .NET dans votre environnement en exécutant la commande suivante.
```
wget https://dot.net/v1/dotnet-install.sh
```
1. Autorisez l'exécution du script d'installation par l'utilisateur actuel en exécutant la commande suivante.
```
sudo chmod u=rx dotnet-install.sh
```
1. Exécutez le script d'installation, qui télécharge et installe le SDK .NET, en exécutant la commande suivante.
```
./dotnet-install.sh -c Current
```
1. Ajoutez le SDK .NET à votre. `PATH` Pour ce faire, dans le profil shell de l'environnement (par exemple, le fichier `.bashrc`), ajoutez le sous-répertoire `$HOME/.dotnet` à la variable `PATH` de l'environnement, comme suit.
1. Ouvrez le fichier `.bashrc` à modifier à l'aide de la commande **`vi`**.
```
vi ~/.bashrc
```
1. Pour Amazon Linux, à l'aide de la flèche vers le bas ou de la touche `j`, passez à la ligne qui commence par `export PATH`.
Pour Ubuntu Server, passez à la dernière ligne du fichier en tapant `G`.
1. À l'aide de la flèche vers la droite ou de la touche `$`, passez à la fin de la ligne.
1. Basculer en mode insertion en appuyant sur la `i` touche. (`-- INSERT ---` s'affiche à la fin de l'affichage.)
1. Pour Amazon Linux, ajoutez le sous-répertoire `$HOME/.dotnet` à la variable ** `PATH` ** en tapant `:$HOME/.dotnet`. Veillez à inclure le caractère deux-points (`:`). La ligne doit ressembler à ce qui suit.
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
Pour Ubuntu Server, appuyez sur la touche flèche droite, puis appuyez deux fois sur `Enter` et saisissez la ligne suivante seule à la fin du fichier.
```
export PATH=$HOME/.dotnet:$PATH
```
1. Enregistrez le fichier. Pour ce faire, appuyez sur la touche `Esc` (`-- INSERT ---` disparaît de la fin de l'affichage), tapez `:wq` (pour écrire sur le fichier, puis le quitter), puis appuyez sur `Enter`.
1. Chargez le SDK .NET en recherchant le `.bashrc` fichier.
```
. ~/.bashrc
```
1. Vérifiez que le SDK .NET est chargé en exécutant .NET CLI avec l'**`--help`**option.
```
dotnet --help
```
En cas de réussite, le numéro de version du SDK .NET est affiché, avec des informations d'utilisation supplémentaires.
1. Si vous ne souhaitez plus conserver le script d'installation du SDK .NET dans votre environnement, vous pouvez le supprimer comme suit.
```
rm dotnet-install.sh
```
## Étape 2 (facultative) : Installer l'extension .NET CLI pour les fonctions Lambda
Bien que cela ne soit pas obligatoire pour ce didacticiel, vous pouvez déployer AWS Lambda des fonctions et AWS Serverless Application Model des applications à l'aide de la CLI .NET si vous installez également le `Amazon.Lambda.Tools` package.
1. Pour installer le paquet, exécutez la commande suivante :
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Maintenant, définissez le `PATH` et la variable d'environnement `DOTNET_ROOT` pour pointer vers l'outil Lambda installé. Dans le fichier `.bashrc`, recherchez la section `export PATH` et modifiez-la pour qu'elle apparaisse comme suit (reportez-vous à l'Étape 1 pour plus de détails sur la modification de ce fichier) :
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```
## Étape 3 : Création d'un projet d'application de console .NET
Au cours de cette étape, vous utilisez .NET pour créer un projet nommé`hello`. Ce projet contient tous les fichiers dont .NET a besoin pour exécuter une application simple depuis le terminal dans l'IDE. Le code de l'application est écrit en C\$1.
Créez un projet d'application de console .NET. Pour ce faire, exécutez la CLI .NET avec la **`new`**commande, en spécifiant le type de modèle de projet d'application console et le langage de programmation à utiliser (dans cet exemple, C\$1).
L'option `-n` indique que le projet est publié dans un nouveau répertoire, `hello`. Puis accédez à ce répertoire.
```
dotnet new console -lang C# -n hello
cd hello
```
La commande précédente ajoute un sous-répertoire nommé `obj` avec plusieurs fichiers, et certains fichiers autonomes supplémentaires, dans le répertoire `hello`. Notez les deux fichiers clés suivants :
+ Le fichier `hello/hello.csproj` contient des informations sur le projet d'application console.
+ Le fichier `hello/Program.cs` contient le code de l'application à exécuter.
## Étape 4 : Ajouter du code
Dans cette étape, vous ajoutez du code à l'application.
Dans la fenêtre **Environnement** de l' AWS Cloud9 IDE, ouvrez le `hello/Program.cs` fichier.
Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `Program.cs`.
```
using System;
namespace hello
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Please provide 2 numbers");
return;
}
Console.WriteLine("Hello, World!");
Console.WriteLine("The sum of 2 and 3 is 5.");
int sum = Int32.Parse(args[0]) + Int32.Parse(args[1]);
Console.WriteLine("The sum of {0} and {1} is {2}.",
args[0], args[1], sum);
}
}
}
```
## Étape 5 : Créer et exécuter le code
Au cours de cette étape, vous allez créer le projet et ses dépendances dans un ensemble de fichiers binaires, y compris un fichier d'application exécutable. Ensuite, vous exécutez l'application.
1. Dans l'IDE, créez un générateur pour .NET comme suit.
1. Dans la barre de menu, choisissez **Exécuter, Système de création, nouveau système de création)**.
1. Sous l'onglet **My Builder.build**, remplacez le contenu de l'onglet par le code suivant.
```
{
"cmd" : ["dotnet", "build"],
"info" : "Building..."
}
```
1. Choisissez **Fichier, Enregistrer sous)**.
1. Pour **Filename (Nom de fichier)**, tapez `.NET.build`.
1. Pour **Folder (Dossier)**, tapez `/.c9/builders`.
1. Choisissez **Enregistrer**.
1. Le contenu du `Program.cs` fichier étant affiché dans l'éditeur, choisissez **Run, Build System, .NET**. Pui, choisissez **Run, Build (Exécuter, Build)**.
Ce générateur ajoute un sous-répertoire nommé `bin`, ainsi qu'un sous-répertoire nommé `Debug`, au sous-répertoire `hello/obj`. Notez les trois fichiers clés suivants.
+ Le fichier `hello/bin/Debug/netcoreapp3.1/hello.dll` est le fichier exécutable de l'application.
+ Le fichier `hello/bin/Debug/netcoreapp3.1/hello.deps.json` répertorie les dépendances de l'application.
+ Le fichier `hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json` spécifie le runtime partagé et sa version pour l'application.
**Note**
Le nom du dossier`netcoreapp3.1`, reflète la version du SDK .NET utilisée dans cet exemple. Vous pouvez voir un numéro différent dans le nom du dossier en fonction de la version que vous avez installée.
1. Créez un runner pour .NET comme suit.
1. Dans la barre de menus, choisissez **Run, Run With, New Runner (Exécuter, Exécuter avec, Nouvel exécuteur)**.
1. Sous l'onglet **My Runner.run**, remplacez le contenu de l'onglet par le code suivant.
```
{
"cmd" : ["dotnet", "run", "$args"],
"working_dir": "$file_path",
"info" : "Running..."
}
```
1. Choisissez **Fichier, Enregistrer sous)**.
1. Pour **Filename (Nom de fichier)**, tapez `.NET.run`.
1. Pour **Folder (Dossier)**, tapez `/.c9/runners`.
1. Choisissez **Enregistrer**.
1. Exécutez l'application avec deux nombres entiers à ajouter (par exemple, `5` et `9`) comme suit.
1. Avec le contenu du fichier `Program.cs` affiché dans l'éditeur, choisissez **Run, Run Configurations, New Run Configuration (Exécuter, Configurations d'exécution, Nouvelle configuration d'exécution)**.
1. Dans l'onglet **[Nouveau] - Idle**, choisissez **Runner : Auto**, puis **.NET**.
1. Dans la zone **Command (Commande)**, entrez `hello 5 9`.
1. Cliquez sur **Exécuter**.
Par défaut, cet exécuteur indique à .NET d'exécuter le `hello.dll` fichier dans le `hello/bin/Debug/netcoreapp3.1` répertoire.
Comparez le résultat obtenu avec ce qui suit.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Étape 6 : créer et configurer un projet d'application de console .NET qui utilise AWS SDK pour .NET
Vous pouvez améliorer cet exemple AWS SDK pour .NET pour créer un compartiment Amazon S3, répertorier vos compartiments disponibles, puis supprimer le compartiment que vous venez de créer.
Dans ce nouveau projet, vous ajoutez une référence au kit AWS SDK pour .NET. C' AWS SDK pour .NET est un moyen pratique d'interagir avec des AWS services tels qu'Amazon S3, à partir de votre code .NET. Vous configurez ensuite la gestion des AWS informations d'identification dans votre environnement. Ils ont AWS SDK pour .NET besoin de ces informations d'identification pour interagir avec AWS les services.
### Pour créer le projet
1. Créez un projet d'application de console .NET. Pour ce faire, exécutez la CLI .NET avec la **`new`**commande, en spécifiant le type de modèle de projet d'application console et le langage de programmation à utiliser.
L'option `-n` indique que le projet est publié dans un nouveau répertoire, `s3`. Puis accédez à ce répertoire.
```
dotnet new console -lang C# -n s3
cd s3
```
1. Ajoutez une référence de projet au paquet Amazon S3 dans le AWS SDK pour .NET. Pour ce faire, exécutez la CLI .NET avec la **`add package`**commande, en spécifiant le nom du package Amazon S3 dans NuGet. (NuGetdéfinit la façon dont les packages pour .NET sont créés, hébergés et consommés, et fournit les outils pour chacun de ces rôles.)
```
dotnet add package AWSSDK.S3
```
Lorsque vous ajoutez une référence de projet au package Amazon S3, vous ajoutez NuGet également une référence de projet au reste du package AWS SDK pour .NET.
**Note**
Pour les noms et les versions des autres packages AWS associés dans NuGet, voir les [NuGetpackages marqués avec aws-sdk](https://www.nuget.org/packages?q=Tags%3A%22aws-sdk%22) sur le site Web. NuGet
### Pour configurer la gestion des AWS informations d'identification
Chaque fois que vous utilisez le AWS SDK pour .NET pour appeler un AWS service, vous devez fournir un ensemble d' AWS informations d'identification avec l'appel. Ces informations d'identification déterminent s'il AWS SDK pour .NET dispose des autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue.
Pour stocker vos informations d'identification au sein de l'environnement, suivez les instructions fournies dans la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique.
Pour plus d'informations, consultez [la section Configuration des AWS informations d'identification](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html) dans le *guide du AWS SDK pour .NET développeur*.
## Étape 7 : ajouter le code du AWS SDK
Au cours de cette étape, vous allez ajouter du code pour interagir avec Amazon S3 et créer un compartiment, supprimer le compartiment que vous venez de créer et répertorier les compartiments disponibles.
Dans la fenêtre **Environnement** de l' AWS Cloud9 IDE, ouvrez le `s3/Program.cs` fichier. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `Program.cs`.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Util;
using System;
using System.Threading.Tasks;
namespace s3
{
class Program
{
async static Task Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Usage: ");
Console.WriteLine("Example: my-test-bucket us-east-2");
return;
}
if (args[1] != "us-east-2") {
Console.WriteLine("Cannot continue. The only supported AWS Region ID is " +
"'us-east-2'.");
return;
}
var bucketRegion = RegionEndpoint.USEast2;
// Note: You could add more valid AWS Regions above as needed.
using (var s3Client = new AmazonS3Client(bucketRegion)) {
var bucketName = args[0];
// Create the bucket.
try
{
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Cannot continue. Cannot create bucket. \n" +
"A bucket named '{0}' already exists.", bucketName);
return;
} else {
Console.WriteLine("\nCreating the bucket named '{0}'...", bucketName);
await s3Client.PutBucketAsync(bucketName);
}
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
// Confirm that the bucket was created.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Created the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Did not create the bucket named '{0}'.", bucketName);
}
// Delete the bucket.
Console.WriteLine("\nDeleting the bucket named '{0}'...", bucketName);
await s3Client.DeleteBucketAsync(bucketName);
// Confirm that the bucket was deleted.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Did not delete the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Deleted the bucket named '{0}'.", bucketName);
};
// List current buckets.
Console.WriteLine("\nMy buckets now are:");
var response = await s3Client.ListBucketsAsync();
foreach (var bucket in response.Buckets)
{
Console.WriteLine(bucket.BucketName);
}
}
}
}
}
```
## Étape 8 : créer et exécuter le code du AWS SDK
Au cours de cette étape, vous allez créer le projet et ses dépendances dans un ensemble de fichiers binaires, y compris un fichier d'application exécutable. Ensuite, vous exécutez l'application.
1. Générez le projet. Pour ce faire, avec le contenu du fichier `s3/Program.cs` affiché dans l'éditeur, dans la barre de menu, choisissez **Run, Build (Exécuter, Build)**.
1. Exécutez l'application avec le nom du compartiment Amazon S3 à créer et l'ID de la région AWS dans laquelle créer le compartiment (par exemple `my-test-bucket` et `us-east-2`) comme suit.
1. Avec le contenu du fichier `s3/Program.cs` toujours affiché dans l'éditeur, choisissez **Run, Run Configurations, New Run Configuration (Exécuter, Configurations d'exécution, Nouvelle configuration d'exécution)**.
1. Dans l'onglet **[Nouveau] - Idle**, choisissez **Runner : Auto**, puis **.NET**.
1. Dans la zone **Commande**, tapez le nom de l'application, le nom du compartiment Amazon S3 à créer et l'ID de la AWS région dans laquelle créer le compartiment (par exemple,`s3 my-test-bucket us-east-2`).
1. Cliquez sur **Exécuter**.
Par défaut, cet exécuteur indique à .NET d'exécuter le `s3.dll` fichier dans le `s3/bin/Debug/netcoreapp3.1` répertoire.
Comparez le résultat obtenu à la sortie suivante.
```
Creating a new bucket named 'my-test-bucket'...
Created the bucket named 'my-test-bucket'.
Deleting the bucket named 'my-test-bucket'...
Deleted the bucket named 'my-test-bucket'.
My buckets now are:
```
## Étape 9 : nettoyer
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, veuillez consulter [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# Tutoriel Node.js pour AWS Cloud9
Ce didacticiel vous permet d'exécuter des scripts Node.js dans un environnement de AWS Cloud9 développement.
Le fait de suivre ce didacticiel et de créer cet exemple peut entraîner des frais sur votre AWS compte. Cela inclut les frais éventuels pour des services tels qu'Amazon EC2 et Amazon S3. Pour plus d'informations, consultez les [sections EC2 Tarification](https://aws.amazon.com/ec2/pricing/) [Amazon et Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prérequis](#sample-nodejs-prereqs)
+ [Étape 1 : Installer les outils requis](#sample-nodejs-install)
+ [Étape 2 : Ajouter du code](#sample-nodejs-code)
+ [Étape 3 : Exécuter le code](#sample-nodejs-run)
+ [Étape 4 : Installation et configuration du AWS SDK pour JavaScript dans Node.js](#sample-nodejs-sdk)
+ [Étape 5 : ajouter le code du AWS SDK](#sample-nodejs-sdk-code)
+ [Étape 6 : Exécuter le code du AWS SDK](#sample-nodejs-sdk-run)
+ [Étape 7 : nettoyer](#sample-nodejs-clean-up)
## Prérequis
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement AWS Cloud9 EC2 de développement existant.** Cet exemple suppose que vous disposez déjà d'un EC2 environnement connecté à une EC2 instance Amazon exécutant Amazon Linux ou Ubuntu Serveur. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Installer les outils requis
Dans cette étape, vous installez Node.js, ce qui est nécessaire pour exécuter cet exemple de code.
1. Dans une session de terminal dans l' AWS Cloud9 IDE, vérifiez si Node.js est déjà installé en exécutant la **`node --version`**commande. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window** (Fenêtre), **New Terminal** (Nouveau terminal).) En cas de réussite, la sortie contient le numéro de version de Node.js. Si Node.js est installé, passez directement à [Étape 2 : Ajouter du code](#sample-nodejs-code).
1. Exécutez la commande ** `yum update` ** (pour Amazon Linux) ou la commande ** `apt update` ** (pour Ubuntu Server) afin d'être sûr que les mises à jour de sécurité et les correctifs les plus récents sont installés.
Pour Amazon Linux :
```
sudo yum -y update
```
Pour Ubuntu Server :
```
sudo apt update
```
1. Pour installer Node.js, commencez par exécuter cette commande pour télécharger Node Version Manager (nvm). (nvm) est un script shell Bash simple qui est utile pour installer et gérer les versions de Node.js. Pour plus d'informations, consultez [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md) sur le GitHub site Web.)
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
```
1. Pour commencer à utiliser nvm, fermez la session de terminal et démarrez-la à nouveau, ou approvisionnez le fichier `~/.bashrc` qui contient les commandes pour charger nvm.
```
. ~/.bashrc
```
1. Exécutez cette commande pour installer Node.js 16 sur Amazon Linux 2, Amazon Linux 1 et Ubuntu 18.04. Les instances Amazon Linux 1 et Ubuntu 18.04 ne prennent en charge Node.js que jusqu'à la version 16.
```
nvm install 16
```
Exécutez cette commande pour installer la dernière version de Node.js sur Amazon Linux 2023 et Ubuntu 22.04 :
```
nvm install --lts && nvm alias default lts/*
```
**Note**
Node.js 20 est installé sur la dernière AWS Cloud9 image AL2 023 et Node.js 18 est installé sur la dernière AWS Cloud9 image Amazon Linux 2. Si vous souhaitez installer Node.js 18 AWS Cloud9 manuellement sur Amazon Linux 2, exécutez la commande suivante dans le terminal AWS Cloud9 IDE :
```
C9_NODE_INSTALL_DIR=~/.nvm/versions/node/v18.17.1
C9_NODE_URL=https://d3kgj69l4ph6w4.cloudfront.net/static/node-amazon/node-v18.17.1-linux-x64.tar.gz
mkdir -p $C9_NODE_INSTALL_DIR
curl -fSsl $C9_NODE_URL | tar xz --strip-components=1 -C "$C9_NODE_INSTALL_DIR"
nvm alias default v18.17.1
nvm use default
echo -e 'nvm use default' >> ~/.bash_profile
```
## Étape 2 : Ajouter du code
Dans l' AWS Cloud9 IDE, créez un fichier avec ce contenu et enregistrez le fichier sous son nom`hello.js`. (Pour créer un fichier, dans la barre de menus, choisissez **Fichier**, **Nouveau fichier**. Pour l'enregistrer, choisissez **Fichier**, **Enregistrer**.)
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
var sum = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## Étape 3 : Exécuter le code
1. Dans l' AWS Cloud9 IDE, dans la barre de menus, choisissez **Run, Run** **Configurations**, **New Run Configuration**.
1. Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **Node.js**.
1. Pour **Commande)**, saisissez `hello.js 5 9`. Dans le code, `5` représente `process.argv[2]`, et `9` représente `process.argv[3]`. (`process.argv[0]` représente le nom de l'exécution (`node`), et `process.argv[1]` représente le nom du fichier (`hello.js`).)
1. Choisissez le bouton **Run** et comparez la sortie.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Sortie Node.js après avoir exécuté le code dans l' AWS Cloud9 IDE\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
## Étape 4 : Installation et configuration du AWS SDK pour JavaScript dans Node.js
Lorsque vous exécutez des scripts Node.js dans AWS Cloud9, vous pouvez choisir entre le AWS SDK pour la JavaScript version 3 (V3) et l'ancien AWS SDK pour la JavaScript version 2 (V2). Comme avec la V2, la V3 vous permet de travailler facilement avec Amazon Web Services, mais elle a été intégrée TypeScript et ajoute plusieurs fonctionnalités fréquemment demandées, telles que les packages modularisés.
------
#### [ AWS SDK for JavaScript (V3) ]
Vous pouvez améliorer cet exemple pour utiliser le AWS SDK JavaScript dans Node.js afin de créer un compartiment Amazon S3, de répertorier vos compartiments disponibles, puis de supprimer le compartiment que vous venez de créer.
Au cours de cette étape, vous installez et configurez le module client du service Amazon S3 du AWS SDK pour JavaScript Node.js, qui fournit un moyen pratique d'interagir avec le AWS service Amazon S3, à partir de votre JavaScript code.
Si vous souhaitez utiliser d'autres AWS services, vous devez les installer séparément. Pour plus d'informations sur l'installation AWS des modules, consultez [le *Guide du AWS développeur (V3).*](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/working-with-services) Pour plus d'informations sur la prise en main de Node.js et du AWS SDK pour JavaScript (V3), voir [Commencer avec Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started-nodejs.html#getting-started-nodejs-setup-structure) dans le *Guide du AWS SDK pour JavaScript développeurs (*V3).
Après avoir installé le AWS SDK pour JavaScript dans Node.js, vous devez configurer la gestion des informations d'identification dans votre environnement. Le AWS SDK de Node.js a besoin JavaScript de ces informations d'identification pour interagir avec les AWS services.
**Pour installer le AWS SDK pour JavaScript dans Node.js**
Utilisez npm pour exécuter la commande **`install`**.
```
npm install @aws-sdk/client-s3
```
Pour plus d'informations, consultez la section [Installation du SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html#installing-jssdk) dans le *Guide du AWS SDK pour JavaScript développeur*.
**Pour configurer la gestion des informations d'identification dans votre environnement**
Chaque fois que vous utilisez le AWS SDK pour appeler un AWS service JavaScript dans Node.js, vous devez fournir un ensemble d'informations d'identification avec l'appel. Ces informations d'identification déterminent si le AWS SDK pour JavaScript Node.js dispose des autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue.
Au cours de cette étape, vous allez stocker vos informations d'identification dans l'environnement. Pour ce faire, suivez les instructions de la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique.
Pour plus d'informations, consultez [Setting Credentials in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) dans le *Guide du développeur AWS SDK pour JavaScript *.
------
#### [ AWS SDK for JavaScript (V2) ]
Vous pouvez améliorer cet exemple pour utiliser le AWS SDK JavaScript dans Node.js afin de créer un compartiment Amazon S3, de répertorier vos compartiments disponibles, puis de supprimer le compartiment que vous venez de créer.
Au cours de cette étape, vous installez et configurez le AWS SDK pour JavaScript Node.js, qui constitue un moyen pratique d'interagir avec des AWS services tels qu'Amazon S3, à partir de votre JavaScript code. Après avoir installé le AWS SDK pour JavaScript dans Node.js, vous devez configurer la gestion des informations d'identification dans votre environnement. Le AWS SDK de Node.js a besoin JavaScript de ces informations d'identification pour interagir avec les AWS services.
**Pour installer le AWS SDK pour JavaScript dans Node.js**
Utilisez npm pour exécuter la commande **`install`**.
```
npm install aws-sdk
```
Pour plus d'informations, consultez la section [Installation du SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html) dans le *Guide du AWS SDK pour JavaScript développeur*.
**Pour configurer la gestion des informations d'identification dans votre environnement**
Chaque fois que vous utilisez le AWS SDK pour appeler un AWS service JavaScript dans Node.js, vous devez fournir un ensemble d'informations d'identification avec l'appel. Ces informations d'identification déterminent si le AWS SDK pour JavaScript Node.js dispose des autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue.
Au cours de cette étape, vous allez stocker vos informations d'identification dans l'environnement. Pour ce faire, suivez les instructions de la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique.
Pour plus d'informations, consultez [Setting Credentials in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) dans le *Guide du développeur AWS SDK pour JavaScript *.
------
## Étape 5 : ajouter le code du AWS SDK
------
#### [ AWS SDK for JavaScript (V3) ]
Au cours de cette étape, vous allez ajouter du code supplémentaire pour interagir avec Amazon S3, créer un compartiment, répertorier les compartiments disponibles, puis supprimer le compartiment que vous venez de créer. Vous exécuterez ce code ultérieurement.
Dans l' AWS Cloud9 IDE, créez un fichier avec ce contenu et enregistrez le fichier sous son nom`s3.js`.
```
import {
CreateBucketCommand,
DeleteBucketCommand,
ListBucketsCommand,
S3Client,
} from "@aws-sdk/client-s3";
const wait = async (milliseconds) => {
return new Promise((resolve) => setTimeout(resolve, milliseconds));
};
export const main = async () => {
const client = new S3Client({});
const now = Date.now();
const BUCKET_NAME = `easy-bucket-${now.toString()}`;
const createBucketCommand = new CreateBucketCommand({ Bucket: BUCKET_NAME });
const listBucketsCommand = new ListBucketsCommand({});
const deleteBucketCommand = new DeleteBucketCommand({ Bucket: BUCKET_NAME });
try {
console.log(`Creating bucket ${BUCKET_NAME}.`);
await client.send(createBucketCommand);
console.log(`${BUCKET_NAME} created`);
await wait(2000);
console.log(`Here are your buckets:`);
const { Buckets } = await client.send(listBucketsCommand);
Buckets.forEach((bucket) => {
console.log(` • ${bucket.Name}`);
});
await wait(2000);
console.log(`Deleting bucket ${BUCKET_NAME}.`);
await client.send(deleteBucketCommand);
console.log(`${BUCKET_NAME} deleted`);
} catch (err) {
console.error(err);
}
};
main();
```
------
#### [ AWS SDK for JavaScript (V2) ]
Au cours de cette étape, vous allez ajouter du code supplémentaire pour interagir avec Amazon S3, créer un compartiment, répertorier les compartiments disponibles, puis supprimer le compartiment que vous venez de créer. Vous exécuterez ce code ultérieurement.
Dans l' AWS Cloud9 IDE, créez un fichier avec ce contenu et enregistrez le fichier sous son nom`s3.js`.
```
if (process.argv.length < 4) {
console.log(
"Usage: node s3.js \n" +
"Example: node s3.js my-test-bucket us-east-2"
);
process.exit(1);
}
var AWS = require("aws-sdk"); // To set the AWS credentials and region.
var async = require("async"); // To call AWS operations asynchronously.
AWS.config.update({
region: region,
});
var s3 = new AWS.S3({ apiVersion: "2006-03-01" });
var bucket_name = process.argv[2];
var region = process.argv[3];
var create_bucket_params = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region,
},
};
var delete_bucket_params = { Bucket: bucket_name };
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback) {
s3.listBuckets(function (err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (var i = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback) {
console.log("\nCreating a bucket named " + bucket_name + "...\n");
s3.createBucket(create_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback) {
console.log("\nDeleting the bucket named " + bucket_name + "...\n");
s3.deleteBucket(delete_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets,
]);
```
------
## Étape 6 : Exécuter le code du AWS SDK
1. Activez le code pour appeler des opérations Amazon S3 de manière asynchrone en utilisant npm pour exécuter la commande ** `install` **.
```
npm install async
```
1. Dans l' AWS Cloud9 IDE, dans la barre de menus, choisissez **Run, Run** **Configurations**, **New Run Configuration**.
1. Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **Node.js**.
1. Si vous utilisez le AWS SDK pour JavaScript (V3), tapez **Command**. `s3.js` Si vous utilisez le AWS SDK pour Javascript (v2), pour le type de **commande**`s3.js my-test-bucket us-east-2`, où `my-test-bucket` se trouvent le nom du compartiment que vous souhaitez créer puis supprimer, et `us-east-2` l'ID de la AWS région dans laquelle vous souhaitez créer le compartiment. Pour en savoir plus IDs, consultez [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) dans le. *Référence générale d'Amazon Web Services*
**Note**
Les noms des compartiments Amazon S3 doivent être uniques pour l'ensemble de votre compte AWS, et pas uniquement pour ce qui est de votre AWS compte.
1. Choisissez le bouton **Run** et comparez la sortie.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Étape 7 : nettoyer
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, consultez [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# Tutoriel PHP pour AWS Cloud9
Ce didacticiel vous permet d'exécuter des scripts PHP dans un environnement de AWS Cloud9 développement.
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 et Amazon S3. Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Conditions préalables](#sample-php-prereqs)
+ [Étape 1 : Installer les outils requis](#sample-php-install)
+ [Étape 2 : Ajouter du code](#sample-php-code)
+ [Étape 3 : Exécuter le code](#sample-php-run)
+ [Étape 4 : Installation et configuration du AWS SDK pour PHP](#sample-php-sdk)
+ [Étape 5 : ajouter le code du AWS SDK](#sample-php-sdk-code)
+ [Étape 6 : Exécuter le code du AWS SDK](#sample-php-sdk-run)
+ [Étape 7 : nettoyer](#sample-php-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Installer les outils requis
Dans cette étape, vous installez PHP, qui est requis pour exécuter cet exemple.
**Note**
La procédure suivante installe PHP uniquement. Pour installer des outils connexes tels qu'un serveur Web Apache et une base de données MySQL, consultez [Tutoriel : Installation d'un serveur Web LAMP sur Amazon Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-LAMP.html) dans le guide de l'*utilisateur Amazon EC2*.
1. Dans une session de terminal dans l' AWS Cloud9 IDE, vérifiez si PHP est déjà installé en exécutant la **`php --version`**commande. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window** (Fenêtre), **New Terminal** (Nouveau terminal).) Si PHP est installé, la sortie contient le numéro de version de PHP. Si PHP est installé, passez directement à [Étape 2 : Ajouter du code](#sample-php-code).
1. Exécutez la commande ** `yum update` ** (pour Amazon Linux) ou la commande ** `apt update` ** (pour Ubuntu Server) afin d'être sûr que les mises à jour de sécurité et les correctifs les plus récents sont installés.
Pour Amazon Linux 2 et Amazon Linux :
```
sudo yum -y update
```
Pour Ubuntu Server :
```
sudo apt update
```
1. Installez PHP en exécutant la commande ** `install` **.
Dans Amazon Linux 2 :
```
sudo amazon-linux-extras install -y php7.2
```
Pour Amazon Linux :
```
sudo yum -y install php72
```
**Note**
Vous pouvez afficher votre version d'Amazon Linux avec la commande suivante :
```
cat /etc/system-release
```
Pour Ubuntu Server :
```
sudo apt install -y php php-xml
```
Pour plus d'informations, consultez [Installation et configuration](http://php.net/manual/en/install.php) sur le site web PHP.
## Étape 2 : Ajouter du code
Dans l' AWS Cloud9 IDE, créez un fichier avec ce contenu et enregistrez le fichier sous son nom`hello.php`. (Pour créer un fichier, dans la barre de menus, choisissez **Fichier**, **Nouveau fichier**. Pour l'enregistrer, choisissez **Fichier**, **Enregistrer**, tapez `hello.php` comme **Nom de fichier**, puis **Enregistrer**.)
```
```
**Note**
Le code précédent ne s'appuie pas sur des fichiers externes. Toutefois, si vous incluez ou avez besoin d'autres fichiers PHP dans votre fichier, et que vous souhaitez utiliser ces fichiers AWS Cloud9 pour compléter le code au fur et à mesure que vous tapez, activez le paramètre **Projet, Support PHP, Activer l'achèvement du code PHP** dans les **préférences**, puis ajoutez les chemins d'accès à ces fichiers dans le paramètre **Projet, Support PHP, PHP Completion Include Paths**. (Pour afficher et modifier vos préférences, choisissez **AWS Cloud9, Preferences** dans la barre de menus.)
## Étape 3 : Exécuter le code
1. Dans l' AWS Cloud9 IDE, dans la barre de menus, choisissez **Run, Run** **Configurations**, **New Run Configuration**.
1. Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **PHP (cli)**.
1. Pour **Commande)**, saisissez `hello.php 5 9`. Dans le code, `5` représente `$argv[1]`, et `9` représente `$argv[2]`. (`$argv[0]` représente le nom du fichier (`hello.php`).)
1. Choisissez le bouton **Run** et comparez la sortie.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Résultat de l'exécution du code PHP dans l' AWS Cloud9 IDE\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/images/ide-php-simple.png)
## Étape 4 : Installation et configuration du AWS SDK pour PHP
Vous pouvez améliorer cet exemple AWS SDK pour PHP pour créer un compartiment Amazon S3, répertorier vos compartiments disponibles, puis supprimer le compartiment que vous venez de créer.
Au cours de cette étape, vous installez et configurez le AWS SDK pour PHP, qui constitue un moyen pratique d'interagir avec AWS des services tels qu'Amazon S3, à partir de votre code PHP. Avant de pouvoir installer le AWS SDK pour PHP, vous devez installer [Composer](https://getcomposer.org/). Après avoir installé le AWS SDK pour PHP, vous devez configurer la gestion des informations d'identification dans votre environnement. Ils ont AWS SDK pour PHP besoin de ces informations d'identification pour interagir avec AWS les services.
### Pour installer Composer
Exécutez la commande ** `curl` ** avec les options d'exécution silencieuse (`-s`) et d'affichage d'erreur (`-S`), en recueillant le programme d'installation Composer dans un fichier d'archive PHP (PHAR), nommé `composer.phar` par convention.
```
curl -sS https://getcomposer.org/installer | php
```
### Pour installer le AWS SDK pour PHP
Pour Ubuntu Server, installez les packages supplémentaires dont Composer a besoin pour installer le kit AWS SDK pour PHP.
```
sudo apt install -y php-xml php-curl
```
Pour Amazon Linux ou Ubuntu Server, utilisez la commande **php** pour exécuter le programme d'installation de Composer afin d'installer le kit AWS SDK pour PHP.
```
php composer.phar require aws/aws-sdk-php
```
Cette commande crée plusieurs dossiers et fichiers dans votre environnement. Le fichier principal que vous utiliserez est `autoload.php`, qui se trouve dans le dossier `vendor` de votre environnement.
**Note**
Après l'installation, Composer peut vous suggérer d'installer des dépendances supplémentaires. Pour ce faire, vous pouvez exécuter une commande semblable à ce qui suit, en spécifiant la liste des dépendances à installer. Par exemple, la commande suivante indique à Composer d'installer la liste suivante de dépendances.
```
php composer.phar require psr/log ext-curl doctrine/cache aws/aws-php-sns-message-validator
```
Pour plus d'informations, consultez [Installation](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/installation.html) dans le *Manuel du développeur AWS SDK pour PHP *.
### Pour configurer la gestion des informations d'identification dans votre environnement
Chaque fois que vous utilisez le AWS SDK pour PHP pour appeler un AWS service, vous devez fournir un ensemble d'informations d'identification avec l'appel. Ces informations d'identification déterminent s'il AWS SDK pour PHP dispose des autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue.
Au cours de cette étape, vous allez stocker vos informations d'identification dans l'environnement. Pour ce faire, suivez les instructions de la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique.
Pour plus d'informations, consultez la section « Création d'un client » de la rubrique [Modèles d'utilisation de base](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/basic-usage.html) dans le *Manuel du développeur AWS SDK pour PHP *.
## Étape 5 : ajouter le code du AWS SDK
Au cours de cette étape, vous allez ajouter du code supplémentaire pour interagir avec Amazon S3, créer un compartiment, répertorier les compartiments disponibles, puis supprimer le compartiment que vous venez de créer. Vous exécuterez ce code ultérieurement.
Dans l' AWS Cloud9 IDE, créez un fichier avec ce contenu et enregistrez le fichier sous son nom`s3.php`.
```
\n" .
"Example: php s3.php America/Los_Angeles my-test-bucket us-east-2");
}
$timeZone = $argv[1];
$bucketName = $argv[2];
$region = $argv[3];
date_default_timezone_set($timeZone);
$s3 = new Aws\S3\S3Client([
'region' => $region,
'version' => '2006-03-01'
]);
# Lists all of your available buckets in this AWS Region.
function listMyBuckets($s3)
{
print("\nMy buckets now are:\n");
$promise = $s3->listBucketsAsync();
$result = $promise->wait();
foreach ($result['Buckets'] as $bucket) {
print("\n");
print($bucket['Name']);
}
}
listMyBuckets($s3);
# Create a new bucket.
print("\n\nCreating a new bucket named '$bucketName'...\n");
try {
$promise = $s3->createBucketAsync([
'Bucket' => $bucketName,
'CreateBucketConfiguration' => [
'LocationConstraint' => $region
]
]);
$promise->wait();
} catch (Exception $e) {
if ($e->getCode() == 'BucketAlreadyExists') {
exit("\nCannot create the bucket. " .
"A bucket with the name '$bucketName' already exists. Exiting.");
}
}
listMyBuckets($s3);
# Delete the bucket you just created.
print("\n\nDeleting the bucket named '$bucketName'...\n");
$promise = $s3->deleteBucketAsync([
'Bucket' => $bucketName
]);
$promise->wait();
listMyBuckets($s3);
?>
```
## Étape 6 : Exécuter le code du AWS SDK
1. Dans l' AWS Cloud9 IDE, dans la barre de menus, choisissez **Run, Run** **Configurations**, **New Run Configuration**.
1. Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **PHP (cli)**.
1. Pour **Command (Commande)**, tapez `s3.php America/Los_Angeles my-test-bucket us-east-2`, où :
+ `America/Los_Angeles` représente votre ID de fuseau horaire par défaut. Pour en savoir plus IDs, consultez [la liste des fuseaux horaires pris en charge](http://php.net/manual/en/timezones.php) sur le site Web de PHP.
+ `my-test-bucket` représente le nom du compartiment que vous souhaitez créer, puis supprimer.
**Note**
Les noms des compartiments Amazon S3 doivent être uniques pour l'ensemble de votre compte AWS, et pas uniquement pour ce qui est de votre AWS compte.
+ `us-east-2`est l'ID de la AWS région dans laquelle vous souhaitez créer le bucket. Pour en savoir plus IDs, consultez [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) dans le. *Référence générale d'Amazon Web Services*
1. Choisissez le bouton **Run** et comparez la sortie.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Étape 7 : nettoyer
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, veuillez consulter [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
### Résolution des problèmes liés à PHP Runner pour AWS Cloud9
Si vous rencontrez des problèmes avec le programme d'exécution de la CLI PHP, vous devez vous assurer que le programme d'exécution a été défini sur PHP et que le mode débogueur est activé.
# AWS SDK pour Ruby in AWS Cloud9
Pour plus d'informations sur l'utilisation AWS Cloud9 du AWS SDK pour Ruby, [consultez la section AWS Cloud9 Utilisation AWS du SDK pour Ruby dans le guide](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/cloud9-ruby.html) du développeur du *SDK AWS pour Ruby*.
**Note**
Le fait de suivre ce didacticiel peut entraîner des frais sur votre AWS compte. Cela inclut les frais éventuels pour des services tels qu'Amazon EC2 et Amazon S3. Pour plus d'informations, consultez les [sections EC2 Tarification](https://aws.amazon.com/ec2/pricing/) [Amazon et Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
# Tutoriel Go pour AWS Cloud9
Ce didacticiel vous permet d'exécuter du code Go dans un environnement de AWS Cloud9 développement.
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 et Amazon S3. Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Conditions préalables](#sample-go-prereqs)
+ [Étape 1 : Installer les outils requis](#sample-go-install)
+ [Étape 2 : Ajouter du code](#sample-go-code)
+ [Étape 3 : Exécuter le code](#sample-go-run)
+ [Étape 4 : Installation et configuration du AWS SDK pour Go](#sample-go-sdk)
+ [Étape 5 : ajouter le code du AWS SDK](#sample-go-sdk-code)
+ [Étape 6 : Exécuter le code du AWS SDK](#sample-go-sdk-run)
+ [Étape 7 : nettoyer](#sample-go-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Installer les outils requis
Dans cette étape, vous installez et configurez Go, ce qui est nécessaire pour exécuter cet exemple de code.
1. Dans une session de terminal dans l' AWS Cloud9 IDE, vérifiez si Go est déjà installé en exécutant la **`go version`**commande. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window**, **New Terminal**.) En cas de réussite, la sortie doit contenir le numéro de version de Go. Dans le cas contraire, un message d'erreur est généré. Si Go est installé, passez directement à [Étape 2 : Ajouter du code](#sample-go-code).
1. Exécutez la commande ** `yum update` ** (pour Amazon Linux) ou la commande ** `apt update` ** (pour Ubuntu Server) afin d'être sûr que les mises à jour de sécurité et les correctifs les plus récents sont installés.
Pour Amazon Linux :
```
sudo yum -y update
```
Pour Ubuntu Server :
```
sudo apt update
```
1. Pour installer Go, exécutez les commandes suivantes, l'une après l'autre.
```
wget https://storage.googleapis.com/golang/go1.9.3.linux-amd64.tar.gz # Download the Go installer.
sudo tar -C /usr/local -xzf ./go1.9.3.linux-amd64.tar.gz # Install Go.
rm ./go1.9.3.linux-amd64.tar.gz # Delete the installer.
```
Les commandes précédentes supposent l'utilisation de la dernière version stable de Go au moment de la rédaction de cette rubrique. Pour plus d'informations, consultez [Downloads](https://golang.org/dl/) sur le site web du langage de programmation Go.
1. Ajoutez le chemin d'accès au fichier binaire Go dans votre variable d'environnement `PATH`, comme suit.
1. Ouvrez votre fichier de profil shell (par exemple, `~/.bashrc`) pour le modifier.
1. À la fin de cette ligne de code, tapez les éléments suivants. Le code ressemble désormais à :
```
PATH=$PATH:/usr/local/go/bin
```
1. Enregistrez le fichier.
1. Définissez le fichier `~/.bashrc` en tant que source, afin que le terminal puisse désormais trouver le fichier binaire Go que vous venez de référencer.
```
. ~/.bashrc
```
1. Vérifiez que Go est maintenant correctement installé et configuré en exécutant la commande ** `go version` **. En cas de réussite, la sortie contient le numéro de version de Go.
## Étape 2 : Ajouter du code
Dans l' AWS Cloud9 IDE, créez un fichier avec ce contenu et enregistrez le fichier sous son nom`hello.go`. (Pour créer un fichier, dans la barre de menus, choisissez **Fichier**, **Nouveau fichier**. Pour l'enregistrer, choisissez **Fichier**, **Enregistrer**.)
```
package main
import (
"fmt"
"os"
"strconv"
)
func main() {
fmt.Printf("Hello, World!\n")
fmt.Printf("The sum of 2 and 3 is 5.\n")
first, _ := strconv.Atoi(os.Args[1])
second, _ := strconv.Atoi(os.Args[2])
sum := first + second
fmt.Printf("The sum of %s and %s is %s.",
os.Args[1], os.Args[2], strconv.Itoa(sum))
}
```
## Étape 3 : Exécuter le code
1. Dans l' AWS Cloud9 IDE, dans la barre de menus, choisissez **Run, Run** **Configurations**, **New Run Configuration**.
1. Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **Go**.
**Note**
Si **Go** n'est pas disponible, vous pouvez créer un exécuteur personnalisé pour Go.
Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **New Runner (Nouvel exécuteur)**.
Dans l'onglet **My Runner.run**, remplacez le contenu de l'onglet par le code suivant.
```
{
"cmd" : ["go", "run", "$file", "$args"],
"info" : "Running $project_path$file_name...",
"selector" : "source.go"
}
```
Choisissez **File (Fichier)**, **Save As (Enregistrer sous)** dans la barre de menus, et enregistrez le fichier sous le nom `Go.run` dans le dossier `/.c9/runners`.
Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **Go**.
Choisissez l'onglet **hello.go** pour l'activer.
1. Pour **Commande)**, saisissez `hello.go 5 9`. Dans le code, `5` représente `os.Args[1]` et `9` représente `os.Args[2]`.
![\[Résultat de l'exécution du code Go dans l' AWS Cloud9 IDE\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/images/ide-go-simple.png)
1. Choisissez le bouton **Run** et comparez la sortie.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Étape 4 : Installation et configuration du AWS SDK pour Go
Vous pouvez améliorer cet exemple AWS SDK pour Go pour créer un compartiment Amazon S3, répertorier vos compartiments disponibles, puis supprimer le compartiment que vous venez de créer.
Au cours de cette étape, vous installez et configurez le AWS SDK pour Go, ce qui constitue un moyen pratique d'interagir avec AWS des services tels qu'Amazon S3, à partir de votre code Go. Avant d'installer le kit AWS SDK pour Go, vous devez définir votre variable d'environnement `GOPATH`. Après avoir installé le kit AWS SDK pour Go et défini votre variable d'environnement `GOPATH`, vous devez configurer la gestion des informations d'identification dans votre environnement. Ils ont AWS SDK pour Go besoin de ces informations d'identification pour interagir avec AWS les services.
### Pour définir votre variable d'environnement GOPATH
1. Ouvrez votre fichier `~/.bashrc` pour le modifier.
1. Après la dernière ligne du fichier, saisissez ce code.
```
GOPATH=~/environment/go
export GOPATH
```
1. Enregistrez le fichier.
1. Définissez le fichier `~/.bashrc` en tant que source, afin que le terminal puisse désormais trouver la variable d'environnement `GOPATH` que vous venez de référencer.
```
. ~/.bashrc
```
1. Vérifiez que la variable d'environnement `GOPATH` est correctement définie en exécutant la commande **`echo $GOPATH`**. En cas de réussite, la valeur `/home/ec2-user/environment/go` ou `/home/ubuntu/environment/go` doit être renvoyée en sortie.
### Pour installer AWS SDK pour Go
Exécutez la **`go get`**commande en spécifiant l'emplacement de la AWS SDK pour Go source.
```
go get -u github.com/aws/aws-sdk-go/...
```
Go installe la AWS SDK pour Go source à l'emplacement spécifié par votre variable d'`GOPATH`environnement, à savoir le `go` dossier de votre environnement.
### Pour configurer la gestion des informations d'identification dans votre environnement
Chaque fois que vous utilisez le AWS SDK pour Go pour appeler un AWS service, vous devez fournir un ensemble d'informations d'identification avec l'appel. Ces informations d'identification déterminent s'il AWS SDK pour Go dispose des autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue.
Au cours de cette étape, vous allez stocker vos informations d'identification dans l'environnement. Pour ce faire, suivez les instructions de la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique.
Pour plus d'informations, consultez [Spécification des informations d’identification](https://docs.aws.amazon.com/sdk-for-go/latest/developer-guide/configuring-sdk.html#specifying-credentials) dans le *Guide du développeur AWS SDK pour Go *.
## Étape 5 : ajouter le code du AWS SDK
Au cours de cette étape, vous allez ajouter du code supplémentaire pour interagir avec Amazon S3, créer un compartiment, répertorier les compartiments disponibles, puis supprimer le compartiment que vous venez de créer. Vous exécuterez ce code ultérieurement.
Dans l' AWS Cloud9 IDE, créez un fichier avec ce contenu et enregistrez le fichier sous son nom`s3.go`.
```
package main
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
)
func main() {
if len(os.Args) < 3 {
fmt.Printf("Usage: go run s3.go \n" +
"Example: go run s3.go my-test-bucket us-east-2\n")
os.Exit(1)
}
sess := session.Must(session.NewSessionWithOptions(session.Options{
SharedConfigState: session.SharedConfigEnable,
}))
svc := s3.New(sess, &aws.Config{
Region: aws.String(os.Args[2]),
})
listMyBuckets(svc)
createMyBucket(svc, os.Args[1], os.Args[2])
listMyBuckets(svc)
deleteMyBucket(svc, os.Args[1])
listMyBuckets(svc)
}
// List all of your available buckets in this AWS Region.
func listMyBuckets(svc *s3.S3) {
result, err := svc.ListBuckets(nil)
if err != nil {
exitErrorf("Unable to list buckets, %v", err)
}
fmt.Println("My buckets now are:\n")
for _, b := range result.Buckets {
fmt.Printf(aws.StringValue(b.Name) + "\n")
}
fmt.Printf("\n")
}
// Create a bucket in this AWS Region.
func createMyBucket(svc *s3.S3, bucketName string, region string) {
fmt.Printf("\nCreating a new bucket named '" + bucketName + "'...\n\n")
_, err := svc.CreateBucket(&s3.CreateBucketInput{
Bucket: aws.String(bucketName),
CreateBucketConfiguration: &s3.CreateBucketConfiguration{
LocationConstraint: aws.String(region),
},
})
if err != nil {
exitErrorf("Unable to create bucket, %v", err)
}
// Wait until bucket is created before finishing
fmt.Printf("Waiting for bucket %q to be created...\n", bucketName)
err = svc.WaitUntilBucketExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// Delete the bucket you just created.
func deleteMyBucket(svc *s3.S3, bucketName string) {
fmt.Printf("\nDeleting the bucket named '" + bucketName + "'...\n\n")
_, err := svc.DeleteBucket(&s3.DeleteBucketInput{
Bucket: aws.String(bucketName),
})
if err != nil {
exitErrorf("Unable to delete bucket, %v", err)
}
// Wait until bucket is deleted before finishing
fmt.Printf("Waiting for bucket %q to be deleted...\n", bucketName)
err = svc.WaitUntilBucketNotExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// If there's an error, display it.
func exitErrorf(msg string, args ...interface{}) {
fmt.Fprintf(os.Stderr, msg+"\n", args...)
os.Exit(1)
}
```
## Étape 6 : Exécuter le code du AWS SDK
1. Dans l' AWS Cloud9 IDE, dans la barre de menus, choisissez **Run, Run** **Configurations**, **New Run Configuration**.
1. Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **Go**.
1. Dans **Command**`s3.go YOUR_BUCKET_NAME THE_AWS_REGION `, saisissez ` YOUR_BUCKET_NAME ` le nom du compartiment que vous souhaitez créer puis supprimer, ainsi ` THE_AWS_REGION ` que l'ID de la AWS région dans laquelle vous souhaitez créer le compartiment. Par exemple, pour la région USA Est (Ohio), utilisez `us-east-2`. Pour en savoir plus IDs, consultez [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) dans le. *Référence générale d'Amazon Web Services*
**Note**
Les noms des compartiments Amazon S3 doivent être uniques pour l'ensemble de votre compte AWS, et pas uniquement pour ce qui est de votre AWS compte.
1. Choisissez le bouton **Run** et comparez la sortie.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Étape 7 : nettoyer
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, veuillez consulter [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# TypeScript tutoriel pour AWS Cloud9
Ce didacticiel explique comment travailler TypeScript dans un environnement AWS Cloud9 de développement.
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 et Amazon S3. Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Conditions préalables](#sample-typescript-prereqs)
+ [Étape 1 : Installer les outils requis](#sample-typescript-install)
+ [Étape 2 : Ajouter du code](#sample-typescript-code)
+ [Étape 3 : Exécuter le code](#sample-typescript-run)
+ [Étape 4 : Installation et configuration du AWS SDK pour JavaScript dans Node.js](#sample-typescript-sdk)
+ [Étape 5 : ajouter le code du AWS SDK](#sample-typescript-sdk-code)
+ [Étape 6 : Exécuter le code du AWS SDK](#sample-typescript-sdk-run)
+ [Étape 7 : nettoyer](#sample-typescript-clean-up)
## Conditions préalables
Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :
+ **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md).
## Étape 1 : Installer les outils requis
Au cours de cette étape, vous devez procéder à TypeScript l'installation à l'aide de Node Package Manager (**`npm`**). Pour installer ** `npm` **, vous utilisez Node Version Manager (** `nvm` **). Si vous ne disposez pas de ** `nvm` **, vous devez d'abord l'installer dans cette étape.
1. Dans une session de terminal dans l' AWS Cloud9 IDE, vérifiez s'il TypeScript est déjà installé en exécutant le TypeScript compilateur de ligne de commande avec l'**`--version`**option. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window** (Fenêtre), **New Terminal** (Nouveau terminal).) En cas de succès, la sortie contient le numéro de TypeScript version. S' TypeScript il est installé, passez directement à[Étape 2 : Ajouter du code](#sample-typescript-code).
```
tsc --version
```
1. Vérifiez si ** `npm` ** est déjà installé en exécutant ** `npm` ** avec l'option ** `--version` **. Si c'est le cas, la sortie contient le numéro de version ** `npm` **. S'il **`npm`**est installé, passez à l'étape 10 de cette procédure à utiliser **`npm`**pour l'installation TypeScript.
```
npm --version
```
1. Exécutez la commande ** `yum update` ** (pour Amazon Linux) ou la commande ** `apt update` ** (pour Ubuntu Server) afin d'être sûr que les mises à jour de sécurité et les correctifs les plus récents sont installés.
Pour Amazon Linux :
```
sudo yum -y update
```
Pour Ubuntu Server :
```
sudo apt update
```
1. Pour l'installer **`npm`**, commencez par exécuter la commande suivante pour télécharger Node Version Manager (**`nvm`**). (**`nvm`**est un script shell Bash simple qui est utile pour installer et gérer les versions de Node.js. Pour plus d'informations, consultez [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md) sur le GitHub site Web.)
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Pour commencer à utiliser ** `nvm` **, fermez la session de terminal et démarrez-la à nouveau, ou approvisionnez le fichier `~/.bashrc` qui contient les commandes pour charger ** `nvm` **.
```
. ~/.bashrc
```
1. Vérifiez que ** `nvm` ** est installé en exécutant ** `nvm` ** avec l'option ** `--version` **.
```
nvm --version
```
1. Installez la dernière version 16 de Node.js en exécutant **`nvm`**. (**`npm`**est inclus dans Node.js.)
```
nvm install v16
```
1. Confirmez que Node.js est installé en exécutant la version de ligne de commande de Node.js avec l'option ** `--version` **.
```
node --version
```
1. Vérifiez que ** `npm` ** est installé en exécutant ** `npm` ** avec l'option ** `--version` **.
```
npm --version
```
1. Installez TypeScript en exécutant **`npm`**l'**`-g`**option. Cela s'installe TypeScript en tant que package global dans l'environnement.
```
npm install -g typescript
```
1. Confirmez qu' TypeScript il est installé en exécutant le TypeScript compilateur de ligne de commande avec l'**`--version`**option.
```
tsc --version
```
## Étape 2 : Ajouter du code
1. Dans l' AWS Cloud9 IDE, créez un fichier nommé`hello.ts`. (Pour créer un fichier, dans la barre de menus, choisissez **Fichier**, **Nouveau fichier**. Pour l'enregistrer, choisissez **Fichier**, **Enregistrer**.)
1. Dans un terminal de l'IDE, depuis le même répertoire que le fichier `hello.ts`, exécutez ** `npm` ** pour installer la bibliothèque `@types/node`.
```
npm install @types/node
```
Cela ajoute un dossier `node_modules/@types/node` dans le même répertoire que le fichier `hello.ts`. Ce nouveau dossier contient les définitions de type Node.js dont vous aurez TypeScript besoin plus loin dans cette procédure pour les `process.argv` propriétés `console.log` et que vous ajouterez au `hello.ts` fichier.
1. Ajoutez le code suivant au fichier `hello.ts` :
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
const sum: number = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## Étape 3 : Exécuter le code
1. Dans le terminal, depuis le même répertoire que le `hello.ts` fichier, lancez le TypeScript compilateur. Spécifiez le fichier `hello.ts` et les bibliothèques supplémentaires à inclure.
```
tsc hello.ts --lib es6
```
TypeScript utilise le `hello.ts` fichier et un ensemble de ECMAScript 6 (ES6) fichiers de bibliothèque pour transpiler le TypeScript code du `hello.ts` fichier en JavaScript code équivalent dans un fichier nommé`hello.js`.
1. Dans la fenêtre **Environment (Environnement)**, ouvrez le fichier `hello.js`.
1. Dans la barre de menus, choisissez **Exécuter**, **Configurations d'exécution**, **Nouvelle configuration d'exécution**.
1. Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **Node.js**.
1. Pour **Commande)**, saisissez `hello.js 5 9`. Dans le code, `5` représente `process.argv[2]`, et `9` représente `process.argv[3]`. (`process.argv[0]` représente le nom de l'exécution (`node`), et `process.argv[1]` représente le nom du fichier (`hello.js`).)
1. Choisissez le bouton **Run (Exécuter)** et comparez la sortie. Lorsque vous avez terminé, choisissez **Stop (Arrêter)**.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Sortie Node.js après avoir exécuté le code dans l' AWS Cloud9 IDE\]](http://docs.aws.amazon.com/fr_fr/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
**Note**
Au lieu de créer une nouvelle configuration d'exécution dans l'IDE, vous pouvez également exécuter ce code en exécutant la commande ** `node hello.js 5 9` ** à partir du terminal.
## Étape 4 : Installation et configuration du AWS SDK pour JavaScript dans Node.js
Vous pouvez améliorer cet exemple pour utiliser le AWS SDK JavaScript dans Node.js afin de créer un compartiment Amazon S3, de répertorier vos compartiments disponibles, puis de supprimer le compartiment que vous venez de créer.
Au cours de cette étape, vous allez installer et configurer le AWS SDK pour JavaScript dans Node.js. Le SDK fournit un moyen pratique d'interagir avec des AWS services tels qu'Amazon S3, à partir de votre JavaScript code. Après avoir installé le AWS SDK pour JavaScript dans Node.js, vous devez configurer la gestion des informations d'identification dans votre environnement. Le SDK a besoin de ces informations d'identification pour interagir avec les AWS services.
### Pour installer le AWS SDK pour JavaScript dans Node.js
Dans une session de terminal dans l' AWS Cloud9 IDE, depuis le même répertoire que le `hello.js` fichier[Étape 3 : Exécuter le code](#sample-typescript-run), exécutez **`npm`**pour installer le AWS SDK pour JavaScript dans Node.js.
```
npm install aws-sdk
```
Cette commande ajoute plusieurs dossiers au dossier `node_modules` de l'[Étape 3 : Exécuter le code](#sample-typescript-run). Ces dossiers contiennent le code source et les dépendances du AWS SDK pour JavaScript Node.js. Pour plus d'informations, consultez la section [Installation du SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html) dans le *Guide du AWS SDK pour JavaScript développeur*.
### Pour configurer la gestion des informations d'identification dans votre environnement
Chaque fois que vous utilisez le AWS SDK pour appeler un AWS service JavaScript dans Node.js, vous devez fournir un ensemble d'informations d'identification avec l'appel. Ces informations d'identification déterminent si le AWS SDK pour JavaScript Node.js dispose des autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue.
Au cours de cette étape, vous allez stocker vos informations d'identification dans l'environnement. Pour ce faire, suivez les instructions de la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique.
Pour plus d'informations, consultez [Setting Credentials in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html) dans le *Guide du développeur AWS SDK pour JavaScript *.
## Étape 5 : ajouter le code du AWS SDK
Au cours de cette étape, vous allez ajouter du code supplémentaire pour interagir avec Amazon S3, créer un compartiment, répertorier les compartiments disponibles, puis supprimer le compartiment que vous venez de créer. Vous exécuterez ce code ultérieurement.
1. Dans l' AWS Cloud9 IDE, dans le même répertoire que le `hello.js` fichier des étapes précédentes, créez un fichier nommé`s3.ts`.
1. À partir d'un terminal de l' AWS Cloud9 IDE, dans le même répertoire que le `s3.ts` fichier, activez le code pour appeler les opérations Amazon S3 de manière asynchrone en exécutant **`npm`**deux fois pour installer la bibliothèque asynchrone pour TypeScript et de nouveau pour. JavaScript
```
npm install @types/async # For TypeScript.
npm install async # For JavaScript.
```
1. Ajoutez le code suivant au fichier `s3.ts` :
```
import * as async from 'async';
import * as AWS from 'aws-sdk';
if (process.argv.length < 4) {
console.log('Usage: node s3.js \n' +
'Example: node s3.js my-test-bucket us-east-2');
process.exit(1);
}
const AWS = require('aws-sdk'); // To set the AWS credentials and AWS Region.
const async = require('async'); // To call AWS operations asynchronously.
const s3: AWS.S3 = new AWS.S3({apiVersion: '2006-03-01'});
const bucket_name: string = process.argv[2];
const region: string = process.argv[3];
AWS.config.update({
region: region
});
const create_bucket_params: any = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region
}
};
const delete_bucket_params: any = {
Bucket: bucket_name
};
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback): void {
s3.listBuckets(function(err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (let i: number = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback): void {
console.log("\nCreating a bucket named '" + bucket_name + "'...\n");
s3.createBucket(create_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback): void {
console.log("\nDeleting the bucket named '" + bucket_name + "'...\n");
s3.deleteBucket(delete_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets
]);
```
## Étape 6 : Exécuter le code du AWS SDK
1. Dans le terminal, depuis le même répertoire que le `s3.ts` fichier, lancez le TypeScript compilateur. Spécifiez le fichier `s3.ts` et les bibliothèques supplémentaires à inclure.
```
tsc s3.ts --lib es6
```
TypeScript utilise le `s3.ts` fichier, le AWS SDK pour JavaScript Node.js, la bibliothèque asynchrone et un ensemble de ECMAScript 6 (ES6) fichiers de bibliothèque pour transpiler le TypeScript code du fichier en JavaScript code équivalent dans un `s3.ts` fichier nommé. `s3.js`
1. Dans la fenêtre **Environment (Environnement)**, ouvrez le fichier `s3.js`.
1. Dans la barre de menus, choisissez **Exécuter**, **Configurations d'exécution**, **Nouvelle configuration d'exécution**.
1. Dans l'onglet **[New] - Idle ([Nouveau] - Inactif)**, choisissez **Runner: Auto (Exécuteur : Auto)**, puis **Node.js**.
1. Dans **Command**`s3.js YOUR_BUCKET_NAME THE_AWS_REGION `, tapez où ` YOUR_BUCKET_NAME ` est le nom du compartiment que vous souhaitez créer puis supprimer, ainsi ` THE_AWS_REGION ` que l'ID de la AWS région dans laquelle le bucket doit être créé. Par exemple, pour la région USA Est (Ohio), utilisez `us-east-2`. Pour en savoir plus IDs, consultez [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) dans le. *Référence générale d'Amazon Web Services*
**Note**
Les noms des compartiments Amazon S3 doivent être uniques pour l'ensemble de votre compte AWS, et pas uniquement pour ce qui est de votre AWS compte.
1. Choisissez le bouton **Run (Exécuter)** et comparez la sortie. Lorsque vous avez terminé, choisissez **Stop (Arrêter)**.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Étape 7 : nettoyer
Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, veuillez consulter [Supprimer un environnement dans AWS Cloud9](delete-environment.md).
# Tutoriel Docker pour AWS Cloud9
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
+ **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
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
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
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
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
+ 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
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
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
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
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
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
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
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*.
## Didacticiels connexes
+ [Pour démarrer](https://docs.aws.amazon.com/robomaker/latest/dg/getting-started.html), AWS RoboMaker consultez le *guide du AWS RoboMaker développeur*. Ce didacticiel permet AWS Cloud9 de modifier, de créer et de regrouper un exemple d'application de robot.