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.
# 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).