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.
# Déploiement d'applications Node.js avec Elastic Beanstalk
Ce chapitre fournit des instructions pour configurer et déployer votre application Web Node.js sur AWS Elastic Beanstalk. Il fournit également des instructions pour les tâches courantes telles que l'intégration de bases de données et l'utilisation du framework Express. Elastic Beanstalk facilite le déploiement, la gestion et le dimensionnement de vos applications Web Node.js à l'aide d'Amazon Web Services.
Vous pouvez déployer votre application en quelques minutes à l'aide de l'interface de ligne de commande Elastic Beanstalk (EB CLI) ou de la console Elastic Beanstalk. Après avoir déployé votre application Elastic Beanstalk, vous pouvez continuer à utiliser l'EB CLI pour gérer votre application et votre environnement, ou vous pouvez utiliser la console Elastic Beanstalk, ou le. AWS CLI APIs
Suivez les step-by-step instructions [QuickStart pour Node.js](nodejs-quickstart.md) pour créer et déployer une application Web *Hello World* Node.js avec l'interface de ligne de commande EB.
**Topics**
+ [QuickStart: Déployer une application Node.js sur Elastic Beanstalk](nodejs-quickstart.md)
+ [Configuration de votre environnement de développement Node.js pour Elastic Beanstalk](nodejs-devenv.md)
+ [Utilisation de la plateforme Elastic Beanstalk Node.js](create_deploy_nodejs.container.md)
+ [Autres exemples d'applications et de didacticiels Elastic Beanstalk pour Node.js](nodejs-getstarted.md)
+ [Déploiement d'une application Node.js Express sur Elastic Beanstalk](create_deploy_nodejs_express.md)
+ [Déploiement d'une application Node.js Express avec clustering sur Elastic Beanstalk](nodejs-express-clustering.md)
+ [Déploiement d'une application Node.js avec DynamoDB vers Elastic Beanstalk](nodejs-dynamodb-tutorial.md)
+ [Ajout d'une instance de base de données Amazon RDS à votre environnement Node.js Elastic Beanstalk](create-deploy-nodejs.rds.md)
+ [Outils et ressources Node.js](create_deploy_nodejs.resources.md)
# QuickStart: Déployer une application Node.js sur Elastic Beanstalk
Ce QuickStart didacticiel explique le processus de création d'une application Node.js et de son déploiement dans un AWS Elastic Beanstalk environnement.
**Non destiné à une utilisation en production**
Les exemples sont destinés uniquement à des fins de démonstration. N'utilisez pas d'exemples d'applications en production.
**Topics**
+ [Votre AWS compte](#nodejs-quickstart-aws-account)
+ [Conditions préalables](#nodejs-quickstart-prereq)
+ [Étape 1 : Création d'une application Node.js](#nodejs-quickstart-create-app)
+ [Étape 2 : Exécutez votre application localement](#nodejs-quickstart-run-local)
+ [Étape 3 : Déployez votre application Node.js avec l'interface de ligne de commande EB](#nodejs-quickstart-deploy)
+ [Étape 4 : Exécutez votre application sur Elastic Beanstalk](#nodejs-quickstart-run-eb-ap)
+ [Étape 5 : nettoyer](#go-tutorial-cleanup)
+ [AWS ressources pour votre application](#nodejs-quickstart-eb-resources)
+ [Étapes suivantes](#nodejs-quickstart-next-steps)
+ [Déployez avec la console Elastic Beanstalk](#nodejs-quickstart-console)
## Votre AWS compte
Si vous n'êtes pas encore AWS client, vous devez créer un AWS compte. L'inscription vous permet d'accéder à Elastic Beanstalk AWS et aux autres services dont vous avez besoin.
Si vous avez déjà un AWS compte, vous pouvez passer à[Conditions préalables](#nodejs-quickstart-prereq).
### Créez un AWS compte
#### Inscrivez-vous pour un Compte AWS
Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.
**Pour vous inscrire à un Compte AWS**
1. Ouvrez l'[https://portal.aws.amazon.com/billing/inscription.](https://portal.aws.amazon.com/billing/signup)
1. Suivez les instructions en ligne.
Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique ou un SMS et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.
Lorsque vous vous inscrivez à un Compte AWS, un *Utilisateur racine d'un compte AWS*est créé. Par défaut, seul l’utilisateur racine a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l’utilisateur racine pour effectuer les [tâches nécessitant un accès utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à [https://aws.amazon.com/](https://aws.amazon.com/)et en choisissant **Mon compte**.
#### Création d’un utilisateur doté d’un accès administratif
Une fois que vous vous êtes inscrit à un utilisateur administratif Compte AWS, que vous Utilisateur racine d'un compte AWS l'avez sécurisé AWS IAM Identity Center, que vous l'avez activé et que vous en avez créé un, afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.
**Sécurisez votre Utilisateur racine d'un compte AWS**
1. Connectez-vous en [AWS Management Console](https://console.aws.amazon.com/)tant que propriétaire du compte en choisissant **Utilisateur root** et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.
Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur racine, consultez [Connexion en tant qu’utilisateur racine](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) dans le *Guide de l’utilisateur Connexion à AWS *.
1. Activez l’authentification multifactorielle (MFA) pour votre utilisateur racine.
Pour obtenir des instructions, consultez la section [Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) dans le guide de l'utilisateur *IAM*.
**Création d’un utilisateur doté d’un accès administratif**
1. Activez IAM Identity Center.
Pour obtenir des instructions, consultez [Activation d’ AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Dans IAM Identity Center, octroyez un accès administratif à un utilisateur.
Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir [Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) dans le *Guide de AWS IAM Identity Center l'utilisateur*.
**Connexion en tant qu’utilisateur doté d’un accès administratif**
+ Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.
Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section [Connexion au portail AWS d'accès](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) dans le *guide de l'Connexion à AWS utilisateur*.
**Attribution d’un accès à d’autres utilisateurs**
1. Dans IAM Identity Center, créez un ensemble d’autorisations qui respecte la bonne pratique consistant à appliquer les autorisations de moindre privilège.
Pour obtenir des instructions, consultez [Création d’un ensemble d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.
Pour obtenir des instructions, consultez [Ajout de groupes](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
## Conditions préalables
Pour suivre les procédures décrites dans ce guide, vous aurez besoin d'un shell ou d'un terminal de ligne de commande pour exécuter des commandes. Dans les listes, les commandes sont précédées d'un symbole d'invite (\$1) et du nom du répertoire actuel, le cas échéant.
```
~/eb-project$ this is a command
this is output
```
Sous Linux et macOS, vous pouvez utiliser le shell et le gestionnaire de package de votre choix. Sur Windows, vous pouvez [installer le sous-système Windows pour Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) afin d'obtenir une version intégrée à Windows d'Ubuntu et de Bash.
### INTERFACE DE LIGNE DE COMMANDE (CLI) EB
Ce tutoriel utilise également l'interface de ligne de commande Elastic Beanstalk (CLI EB). Pour de plus amples informations sur l'installation et la configuration de la CLI EB, veuillez consulter [Installation de la CLI EB avec un script de configuration (recommandé)](eb-cli3.md#eb-cli3-install) et [Configuration de l'interface de ligne de commande EB](eb-cli3-configuration.md).
### Node.js
Installez Node.js sur votre ordinateur local en suivant la procédure [d'installation de Node.js](https://nodejs.org/en/learn/getting-started/how-to-install-nodejs) sur le site Web Node.js.
Vérifiez votre installation de Node.js en exécutant la commande suivante.
```
~$ node -v
```
## Étape 1 : Création d'une application Node.js
Créez un répertoire de projet.
```
~$ mkdir eb-nodejs
~$ cd eb-nodejs
```
Créez ensuite une application qui vous allez déployer à l'aide d'Elastic Beanstalk. Nous allons créer un service RESTful Web « Hello World ».
**Example `~/eb-nodejs/server.js`**
```
const http = require('node:http');
const hostname = '127.0.0.1';
const port = 8080;
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Hello Elastic Beanstalk!\n');
});
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`);
});
```
Cette application ouvre un écouteur sur le port 8080. Elastic Beanstalk transmet les demandes à votre application sur le port 8080 par défaut pour Node.js.
## Étape 2 : Exécutez votre application localement
Exécutez la commande suivante pour exécuter votre application localement.
```
~/eb-nodejs$ node server.js
```
Vous devriez voir le texte suivant.
```
Server running at http://127.0.0.1:8080/
```
Entrez l'adresse URL `http://127.0.0.1:8080/` dans votre navigateur Web. Le navigateur doit afficher « Hello Elastic Beanstalk \$1 ».
## Étape 3 : Déployez votre application Node.js avec l'interface de ligne de commande EB
Exécutez les commandes suivantes pour créer un environnement Elastic Beanstalk pour cette application.
**Pour créer un environnement et déployer votre application Node.js**
1. Initialisez votre référentiel de la CLI EB avec la commande **eb init** :
```
~/eb-nodejs$ eb init -p node.js nodejs-tutorial --region us-east-2
```
Cette commande crée une application nommée `nodejs-tutorial` et configure votre référentiel local pour créer des environnements avec la dernière version de la plateforme Node.js.
1. (Facultatif) Exécutez à **eb init** nouveau pour configurer une paire de clés par défaut afin de pouvoir utiliser SSH pour vous connecter à l' EC2 instance qui exécute votre application.
```
~/eb-nodejs$ eb init
Do you want to set up SSH for your instances?
(y/n): y
Select a keypair.
1) my-keypair
2) [ Create new KeyPair ]
```
Sélectionnez une paire de clés si vous en avez déjà une, ou suivez les invites pour en créer une. Si vous ne voyez pas l'invite ou que vous avez besoin de modifier vos paramètres ultérieurement, exécutez **eb init -i**.
1. Créez un environnement et déployez-y votre application avec **eb create**. Elastic Beanstalk crée automatiquement un fichier zip pour votre application et le déploie sur une instance de l' EC2 environnement. Après avoir déployé votre application, Elastic Beanstalk la démarre sur le port 8080.
```
~/eb-nodejs$ eb create nodejs-env
```
Il faut environ cinq minutes à Elastic Beanstalk pour créer votre environnement.
## Étape 4 : Exécutez votre application sur Elastic Beanstalk
Lorsque le processus de création de votre environnement est terminé, ouvrez votre site Web avec**eb open**.
```
~/eb-nodejs$ eb open
```
Félicitations \$1 Vous avez déployé une application Node.js avec Elastic Beanstalk \$1 Celle-ci ouvre une fenêtre de navigation en utilisant le nom de domaine créé pour votre application.
## Étape 5 : nettoyer
Vous pouvez mettre fin à votre environnement lorsque vous avez fini d'utiliser votre application. Elastic Beanstalk AWS met fin à toutes les ressources associées à votre environnement.
Pour terminer votre environnement Elastic Beanstalk avec l'EB CLI, exécutez la commande suivante.
```
~/eb-nodejs$ eb terminate
```
## AWS ressources pour votre application
Vous venez de créer une application à instance unique. Il s'agit d'un exemple d'application simple avec une seule EC2 instance, il ne nécessite donc pas d'équilibrage de charge ni de dimensionnement automatique. Pour les applications à instance unique, Elastic Beanstalk crée les ressources suivantes : AWS
+ **EC2 instance** — Une machine EC2 virtuelle Amazon configurée pour exécuter des applications Web sur la plateforme de votre choix.
Chaque plateforme exécute un ensemble distinct de logiciels, de fichiers de configuration et de scripts pour prendre en charge une version de langage, une infrastructure ou un conteneur web spécifiques, ou une combinaison de ces éléments. La plupart des plateformes utilisent Apache ou nginx comme proxy inverse qui traite le trafic web devant votre application web, lui transmet les demandes, traite les ressources statiques et génère des journaux d'accès et d'erreurs.
+ **Groupe de sécurité d'instance** : groupe EC2 de sécurité Amazon configuré pour autoriser le trafic entrant sur le port 80. Cette ressource permet au trafic HTTP provenant de l'équilibreur de charge d'atteindre l' EC2 instance qui exécute votre application Web. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **Compartiment Amazon S3** – Emplacement de stockage pour votre code source, les journaux et autres artefacts qui sont créés lorsque vous utilisez Elastic Beanstalk.
+ ** CloudWatch Alarmes Amazon** : deux CloudWatch alarmes qui surveillent la charge sur les instances de votre environnement et sont déclenchées si la charge est trop élevée ou trop faible. Lorsqu'une alarme est déclenchée, votre groupe Auto Scaling s'adapte en fonction, à la hausse ou à la baisse.
+ **CloudFormation stack** — Elastic CloudFormation Beanstalk utilise pour lancer les ressources de votre environnement et propager les modifications de configuration. Les ressources sont définies dans un modèle, que vous pouvez afficher dans la [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nom de domaine** : nom de domaine qui permet d'accéder à votre application Web dans le formulaire **subdomain*. *region*.elasticbeanstalk.com*.
Elastic Beanstalk gère toutes ces ressources. Lorsque vous arrêtez votre environnement, Elastic Beanstalk arrête toutes les ressources qu'il contient.
## Étapes suivantes
Dès que vous disposez d'un environnement exécutant une application, vous pouvez à tout moment déployer une nouvelle version de l'application ou une application totalement différente. Le déploiement d'une nouvelle version d'application est très rapide car il ne nécessite ni le provisionnement ni le redémarrage des instances. EC2 Vous pouvez également explorer votre nouvel environnement à l'aide de la console Elastic Beanstalk. Pour connaître les étapes détaillées, consultez la section [Explorez votre environnement](GettingStarted.md#GettingStarted.Explore) dans le chapitre *Mise* en route de ce guide.
**Essayez d'autres didacticiels**
Si vous souhaitez essayer d'autres didacticiels avec différents exemples d'applications, consultez[Autres exemples d'applications et de didacticiels Elastic Beanstalk pour Node.js](nodejs-getstarted.md).
Une fois que vous avez déployé un ou deux exemples d'applications et que vous êtes prêt à commencer à développer et à exécuter des applications Node.js localement, consultez[Configuration de votre environnement de développement Node.js pour Elastic Beanstalk](nodejs-devenv.md).
## Déployez avec la console Elastic Beanstalk
Vous pouvez également utiliser la console Elastic Beanstalk pour lancer l'exemple d'application. Pour connaître les étapes détaillées, voir [Création d'un exemple d'application](GettingStarted.md#GettingStarted.CreateApp) dans le chapitre *Mise* en route de ce guide.
# Configuration de votre environnement de développement Node.js pour Elastic Beanstalk
Cette rubrique fournit des instructions pour configurer un environnement de développement Node.js afin de tester votre application localement avant de la déployer AWS Elastic Beanstalk. Il fait également référence à des sites Web qui fournissent des instructions d'installation pour des outils utiles.
**Topics**
+ [Installation de Node.js.](#nodejs-devenv-nodejs)
+ [Confirmation de l'installation de npm](#nodejs-devenv-npm)
+ [Installez le AWS SDK pour Node.js](#nodejs-devenv-awssdk)
+ [Installation du générateur Express](#nodejs-devenv-express)
+ [Configuration d'un cadre et d'un serveur Express](#nodejs-devenv-express-framework)
## Installation de Node.js.
Installez Node.js pour exécuter des applications Node.js localement. Si vous n'avez pas de préférence, téléchargez la dernière version prise en charge par Elastic Beanstalk. Pour obtenir la liste des versions prises en charge, accédez à [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) dans le document *Plateformes AWS Elastic Beanstalk *.
Téléchargez Node.js sur [nodejs.org](https://nodejs.org/en/).
## Confirmation de l'installation de npm
Node.js utilise le gestionnaire de package npm pour vous aider à installer les outils et les infrastructures à utiliser dans votre application. Comme npm est distribué avec Node.js, vous l'installez automatiquement lorsque vous téléchargez et installez Node.js. Pour confirmer que npm est installé, vous pouvez exécuter la commande suivante :
```
$ npm -v
```
Pour plus d'informations sur npm, visitez le site Web de [npmjs](https://www.npmjs.com/get-npm).
## Installez le AWS SDK pour Node.js
Si vous devez gérer AWS des ressources depuis votre application, installez le AWS SDK pour JavaScript dans Node.js. Installez le SDK avec npm :
```
$ npm install aws-sdk
```
Consultez la page d'accueil du [AWS SDK pour JavaScript in Node.js](https://aws.amazon.com/sdk-for-node-js/) pour plus d'informations.
## Installation du générateur Express
Express est une infrastructure d'application web qui s'exécute sur Node.js. Pour l'utiliser, installez d'abord l'application de ligne de commande du générateur Express. Une fois le générateur Express installé, vous pouvez exécuter la commande **express** pour générer une structure de projet de base pour votre application web. Une fois le projet de base, les fichiers et les dépendances installés, vous pouvez démarrer un serveur Express local sur votre ordinateur de développement.
**Note**
Ces étapes vous guident dans l'installation du générateur Express sur un système d'exploitation Linux.
Pour Linux, en fonction de votre niveau d'autorisation aux répertoires du système, il se peut que vous ayez besoin de préfixer certaines de ces commandes `sudo`.
**Pour installer le générateur Express dans votre environnement de développement**
1. Créez un répertoire de travail pour votre cadre et votre serveur Express.
```
~$ mkdir node-express
~$ cd node-express
```
1. Installez Express globalement afin de pouvoir accéder à la commande `express`.
```
~/node-express$ npm install -g express-generator
```
1. En fonction de votre système d'exploitation, vous pouvez avoir besoin de définir le chemin d'accès pour exécuter la commande `express`. La sortie de l'étape précédente vous indique si vous devez définir votre variable de chemin d'accès. Voici un exemple pour Linux.
```
~/node-express$ export PATH=$PATH:/usr/local/share/npm/bin/express
```
Lorsque vous suivrez les tutoriels de ce chapitre, vous devrez exécuter la commande **express** à partir de différents répertoires. Chaque tutoriel définit une structure de projet Express de base dans son propre répertoire.
Vous avez maintenant installé le générateur de ligne de commande Express. Vous pouvez l'utiliser pour créer un répertoire de cadre pour votre application web, configurer les dépendances et démarrer le serveur de l'application web. Nous allons maintenant passer en revue les étapes à suivre pour y parvenir dans le répertoire `node-express` que nous avons créé.
## Configuration d'un cadre et d'un serveur Express
Suivez ces étapes pour créer les répertoires et le contenu du cadre Express de base. Les tutoriels de ce chapitre comprennent également ces étapes pour configurer le cadre Express de base dans chacun des répertoires d'application du tutoriel.
**Pour configurer un cadre et un serveur Express**
1. Exécutez la commande `express`. Il en résulte la génération de `package.json`, `app.js`, et de quelques répertoires.
```
~/node-express$ express
```
Lorsque vous êtes invité à continuer, tapez **y**.
1. Configurez les dépendances locales.
```
~/node-express$ npm install
```
1. Vérifiez que le serveur de l'application web démarre.
```
~/node-express$ npm start
```
Vous devez voir des résultats similaires à ce qui suit :
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
Par défaut, le serveur s'exécute sur le port 3000. Pour le tester, exécutez `curl http://localhost:3000` sur un autre terminal, ou ouvrez un navigateur sur l'ordinateur local et entrez l'adresse URL `http://localhost:3000`.
Appuyez sur **Ctrl\$1C** afin d'arrêter le serveur.
# Utilisation de la plateforme Elastic Beanstalk Node.js
Cette rubrique explique comment configurer, créer et exécuter vos applications Node.js sur Elastic Beanstalk.
AWS Elastic Beanstalk prend en charge un certain nombre de branches de plate-forme pour différentes versions du langage de programmation Node.js. Voir [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) dans le document *AWS Elastic Beanstalk Platforms* pour une liste complète.
Elastic Beanstalk fournit des [options de configuration](command-options.md) que vous pouvez utiliser pour personnaliser le logiciel qui s'exécute sur des instances EC2 dans votre environnement Elastic Beanstalk. Vous pouvez [configurer des variables d'environnement](environments-cfg-softwaresettings.md#environments-cfg-softwaresettings-console) requises pour votre application, activer la rotation des journaux sur Amazon S3 et mapper des dossiers dans la source de votre application contenant des fichiers statiques vers des chemins desservis par le serveur proxy.
Des options de configuration sont disponibles dans la console Elastic Beanstalk pour [modifier la configuration d'un environnement en cours d'exécution](environment-configuration-methods-after.md). Pour éviter de perdre la configuration de votre environnement en le résiliant, vous pouvez utiliser des [configurations enregistrées](environment-configuration-savedconfig.md) pour enregistrer vos paramètres et les appliquer par la suite à un autre environnement.
Pour enregistrer les paramètres dans votre code source, vous pouvez inclure des [fichiers de configuration](ebextensions.md). Les paramètres des fichiers de configuration sont appliquées chaque fois que vous créez un environnement ou que vous déployez votre application. Vous pouvez également utiliser des fichiers de configuration pour installer des packages, exécuter des scripts ou effectuer d'autres opérations de personnalisation d'instance lors des déploiements.
Vous pouvez [inclure un fichier `Package.json`](nodejs-platform-dependencies.md#nodejs-platform-packagejson) dans votre offre groupée source pour installer des packages pendant le déploiement, fournir une commande de démarrage et spécifier la version Node.js que vous souhaitez que votre application utilise. Vous pouvez inclure un [fichier `npm-shrinkwrap.json`](nodejs-platform-shrinkwrap.md) pour verrouiller les versions de dépendances.
La plateforme Node.js inclut un serveur proxy qui diffuse les ressources statiques, achemine le trafic vers votre application et compresse les réponses. Vous pouvez [étendre ou remplacer la configuration du serveur proxy par défaut](nodejs-platform-proxy.md) pour les scénarios avancés.
Il existe plusieurs options pour démarrer votre application. Vous pouvez ajouter un [Procfile](nodejs-configuration-procfile.md) à votre offre groupée source pour spécifier la commande qui démarre votre application. Lorsque vous ne fournissez pas de `Procfile` mais un fichier `package.json`, Elastic Beanstalk exécute `npm start`. Si vous n'en fournissez pas non plus, Elastic Beanstalk recherche le fichier `app.js` ou `server.js`, dans cet ordre, et exécute le script.
Les paramètres appliqués dans la console Elastic Beanstalk remplacent les mêmes paramètres des fichiers de configuration, s'ils existent. Cela vous permet d'utiliser les paramètres par défaut dans les fichiers de configuration et de les remplacer par des paramètres spécifiques à l'environnement dans la console. Pour plus d'informations sur la priorité et les autres méthodes de modification des paramètres, consultez [Options de configuration](command-options.md).
Pour plus d'informations sur les différentes manières d'étendre une plateforme Elastic Beanstalk basée sur Linux, consultez [Extension des plateformes Linux Elastic Beanstalk](platforms-linux-extend.md).
## Configuration de votre environnement Node.js
Vous pouvez utiliser les paramètres de la plateforme Node.js pour affiner le comportement de vos instances Amazon EC2. Vous pouvez modifier la configuration des instances Amazon EC2 de votre environnement Elastic Beanstalk à l'aide de la console Elastic Beanstalk.
Utilisez la console Elastic Beanstalk pour permettre la rotation des journaux sur Amazon S3 et configurer des variables que votre application peut lire à partir de l'environnement.
**Pour configurer votre environnement Node.js dans la console Elastic Beanstalk**
1. Ouvrez la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk), puis **dans la liste des régions, sélectionnez votre**. Région AWS
1. Dans le panneau de navigation, choisissez **Environments** (Environnements), puis choisissez le nom de votre environnement dans la liste.
1. Dans le panneau de navigation, choisissez **Configuration**.
1. Dans la catégorie de configuration **Mises à jour, surveillance et journalisation**, sélectionnez **Modifier**.
### Options de conteneur
Vous pouvez spécifier ces options spécifiques à la plateforme :
+ **Proxy server (Serveur proxy)** – Serveur proxy à utiliser sur vos instances d'environnement. Par défaut, NGINX est utilisé.
### Options du journal
La section **Options du journal** a deux paramètres :
+ **Instance profile (Profil d'instance)** – Spécifie le profil d'instance qui est autorisé à accéder au compartiment Amazon S3 associé à votre application.
+ **Enable log file rotation to Amazon S3** (Permettre la rotation du fichier journal sur Amazon S3) – Indique si les fichiers journaux des instances Amazon EC2 de votre application doivent être copiés dans le compartiment Amazon S3 associé à votre application.
### Fichiers statiques
Pour améliorer les performances, la section des **Fichiers statiques** vous permet de configurer le serveur proxy pour proposer des fichiers statiques (HTML ou images, par exemple) à partir d'un ensemble de répertoires dans votre application web. Pour chaque répertoire, vous définissez le chemin virtuel sur le mappage de répertoires. Lorsque le serveur proxy reçoit une demande pour un fichier dans le chemin spécifié, il fournit le fichier directement au lieu d'acheminer la demande vers votre application.
Pour en savoir plus sur la configuration des fichiers statiques à l'aide des fichiers de configuration ou de la console Elastic Beanstalk, consultez [Service de fichiers statiques](environment-cfg-staticfiles.md).
### Propriétés de l'environnement
Utilisez la section **Environment Properties** pour spécifier des paramètres de configuration de l'environnement sur les instances Amazon EC2 exécutant votre application. Ces paramètres sont passés en tant que paires clé-valeur à l'application.
Dans l'Node.jsenvironnement qui s'exécute AWS Elastic Beanstalk, vous pouvez accéder aux variables d'environnement en exécutant`process.env.ENV_VARIABLE`.
```
var endpoint = process.env.API_ENDPOINT
```
La plateforme Node.js définit la variable d'environnement PORT sur le port vers lequel le serveur proxy transfère le trafic. Pour de plus amples informations, veuillez consulter [Configuration du serveur proxy](nodejs-platform-proxy.md).
Pour plus d’informations, consultez [Variables d'environnement et autres paramètres du logiciel](environments-cfg-softwaresettings.md).
### Configuration d'un environnement Node.js Amazon Linux AMI (antérieure à Amazon Linux 2)
Les catégories de configuration logicielles de console suivantes sont prises en charge uniquement sur un environnement Elastic Beanstalk Node.js qui utilise une version de plateforme Amazon Linux AMI (antérieure à Amazon Linux 2).
**Remarques**
Les informations de cette rubrique s'appliquent uniquement aux branches de plate-forme basées sur l'AMI Amazon Linux (AL1). AL2023Les branches/AL2 platform sont incompatibles avec les versions précédentes de la plateforme Amazon Linux AMI (AL1) et *nécessitent des paramètres de configuration différents*.
[Le 18 juillet 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk a défini le statut de toutes les branches de la plateforme sur la base de l'AMI AL1 Amazon Linux () comme étant supprimées.** Pour plus d'informations sur la migration vers une branche de plateforme Amazon Linux 2023 actuelle et entièrement prise en charge, consultez [Migration de votre application Elastic Beanstalk Linux vers Amazon Linux 2023 ou Amazon Linux 2](using-features.migration-al.md).
#### Options de conteneur — AMI Amazon Linux (AL1)
Sur la page de configuration, spécifiez les informations suivantes :
+ **Proxy serveur** (Serveur proxy) – Indique le serveur web à utiliser comme proxy pour se connecter à Node.js. Par défaut, NGINX est utilisé. Si vous sélectionnez **none** (aucun), les mappages de fichiers statiques ne prendront pas effet et la compression GZIP sera désactivée.
+ **version Node.js** : spécifie la version de Node.js. Pour obtenir la liste des versions Node.js prises en charge, consultez [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) dans le guide * des plateformes AWS Elastic Beanstalk *.
+ **GZIP compression** (Compression ) : indique si la compression GZIP est activée. La compression GZIP est activée par défaut.
+ **Node command** (Commande Node) : vous permet de saisir la commande utilisée pour démarrer l'application Node.js. Une chaîne vide (par défaut) signifie qu'Elastic Beanstalk utilise`app.js`, puis `server.js`et ensuite `npm start`.
## Espaces de noms de la configuration Node.js
Vous pouvez utiliser un [fichier de configuration](ebextensions.md) pour définir des options de configuration et exécuter d'autres tâches de configuration d'instance pendant les déploiements. Les options de configuration peuvent être [spécifiques à la plate-forme](command-options-specific.md) ou s'appliquer à [toutes les plateformes](command-options-general.md) du service Elastic Beanstalk dans son ensemble. Les options de configuration sont organisées en *espaces de noms.*
Vous pouvez choisir le proxy à utiliser sur les instances de votre environnement à l'aide de l'espace de noms `aws:elasticbeanstalk:environment:proxy`. L'exemple suivant configure votre environnement pour qu'il utilise le serveur proxy Apache HTTPD.
**Example .ebextensions/nodejs-settings.config**
```
option_settings:
aws:elasticbeanstalk:environment:proxy:
ProxyServer: apache
```
Vous pouvez configurer le proxy pour qu'il traite les fichiers statiques à l'aide de l'espace de noms `aws:elasticbeanstalk:environment:proxy:staticfiles`. Pour plus d'informations et pour voir un exemple, consultez [Service de fichiers statiques](environment-cfg-staticfiles.md).
Elastic Beanstalk fournit de nombreuses options de configuration pour personnaliser votre environnement. En plus des fichiers de configuration, vous pouvez également définir des options de configuration à l'aide de la console, de configurations enregistrées, de la CLI EB ou d' AWS CLI. Pour plus d’informations, consultez [Options de configuration](command-options.md).
## Plateforme Node.js d'Amazon Linux AMI (antérieure à Amazon Linux 2)
Si votre environnement Elastic Beanstalk Node.js utilise une version de plateforme Amazon Linux AMI (antérieure à Amazon Linux 2), tenez compte des configurations et recommandations spécifiques de cette section.
**Remarques**
Les informations de cette rubrique s'appliquent uniquement aux branches de plate-forme basées sur l'AMI Amazon Linux (AL1). AL2023Les branches/AL2 platform sont incompatibles avec les versions précédentes de la plateforme Amazon Linux AMI (AL1) et *nécessitent des paramètres de configuration différents*.
[Le 18 juillet 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk a défini le statut de toutes les branches de la plateforme sur la base de l'AMI AL1 Amazon Linux () comme étant supprimées.** Pour plus d'informations sur la migration vers une branche de plateforme Amazon Linux 2023 actuelle et entièrement prise en charge, consultez [Migration de votre application Elastic Beanstalk Linux vers Amazon Linux 2023 ou Amazon Linux 2](using-features.migration-al.md).
### Node.jsoptions de configuration spécifiques à la plate-forme — AMI Amazon Linux () AL1
Elastic Beanstalk prend en charge certaines options de configuration spécifiques à la plateforme pour les versions de plateforme Node.js d’Amazon Linux AMI. Vous pouvez choisir le serveur proxy à exécuter devant votre application, une version spécifique de Node.js à exécuter et la commande utilisée pour exécuter votre application.
Pour le serveur proxy, vous pouvez utiliser un serveur proxy NGINX ou Apache. Vous pouvez définir la valeur `none` sur l'option `ProxyServer`. Dans ce cas, Elastic Beanstalk exécute votre application en mode autonome, pas derrière un serveur proxy. Si votre environnement exécute une application autonome, mettez à jour votre code pour écouter le port vers lequel NGINX transfère le trafic.
```
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log('Server running at http://127.0.0.1:%s', port);
});
```
### Node.jsversions linguistiques — Amazon Linux AMI (AL1)
En termes de version linguistique prise en charge, la plateforme Amazon Linux AMI Node.js est différente des autres plateformes gérées par Elastic Beanstalk. En effet, chaque version de la plateforme Node.js ne prend en charge que quelques versions linguistiques Node.js. Pour obtenir la liste des versions Node.js prises en charge, consultez [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) dans le guide *Plateformes AWS Elastic Beanstalk *.
Vous pouvez utiliser une option de configuration spécifique à la plateforme pour définir la version de langage. Pour obtenir des instructions, veuillez consulter [Configuration de votre environnement Node.js](#nodejs-platform-console). Vous pouvez également utiliser la console Elastic Beanstalk pour mettre à jour la version Node.js que votre environnement utilise dans le cadre de la mise à jour de la version de votre plateforme .
**Note**
Lorsque la prise en charge de la version de Node.js que vous utilisez est supprimée de la plateforme, vous devez modifier ou supprimer le paramètre de version avant de procéder à une [mise à jour de la plateforme](using-features.platform.upgrade.md). Cela peut se produire lorsqu'une faille de sécurité est identifiée pour une ou plusieurs versions de Node.js
Dans ce cas, la tentative de mise à jour vers une nouvelle version de la plate-forme qui ne prend pas en charge la configuration [NodeVersion](command-options-specific.md#command-options-nodejs)échoue. Pour éviter d'avoir à créer un nouvel environnement, remplacez l'option de *NodeVersion*configuration par une version de Node.js prise en charge à la fois par l'ancienne version de plate-forme et par la nouvelle, ou [supprimez le paramètre d'option](environment-configuration-methods-after.md), puis effectuez la mise à jour de la plate-forme.
**Pour configurer la version Node.js de votre environnement dans la console Elastic Beanstalk**
1. Ouvrez la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk), puis **dans la liste des régions, sélectionnez votre**. Région AWS
1. Dans le panneau de navigation, choisissez **Environments** (Environnements), puis choisissez le nom de votre environnement dans la liste.
1. Dans la page de présentation de l'environnement, sous **Platform (Plateforme)**, choisissez **Change (Changer)**.
1. Dans la boîte de dialogue **Update platform version** (Mettre à jour la version de la plateforme) sélectionnez une version Node.js.
![\[Confirmation de la mise à jour de la version de la plateforme Elastic Beanstalk\]](http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/images/platform-nodejs-update-node-version.png)
1. Choisissez **Enregistrer**.
### Node.jsespaces de noms de configuration — AMI Amazon Linux () AL1
La plateforme Amazon Linux AMI Node.js définit des options supplémentaire dans les espaces de noms `aws:elasticbeanstalk:container:nodejs:staticfiles` et `aws:elasticbeanstalk:container:nodejs`.
Le fichier de configuration suivant indique à Elastic Beanstalk d'utiliser `npm start` pour exécuter l'application. Il définit également le type de proxy sur Apache et active la compression. Enfin, il configure le proxy pour qu'il serve des fichiers statiques à partir de deux répertoires sources. Une source est constituée de fichiers HTML situés sur le chemin `html` sous la racine du site web à partir du répertoire source `statichtml`. L'autre source est constituée de fichiers image situés sur le chemin `images` sous la racine du site web à partir du répertoire source `staticimages`.
**Example .ebextensions/node-settings.config**
```
option_settings:
aws:elasticbeanstalk:container:nodejs:
NodeCommand: "npm start"
ProxyServer: apache
GzipCompression: true
aws:elasticbeanstalk:container:nodejs:staticfiles:
/html: statichtml
/images: staticimages
```
Elastic Beanstalk fournit de nombreuses options de configuration pour personnaliser votre environnement. En plus des fichiers de configuration, vous pouvez également définir des options de configuration à l'aide de la console, de configurations enregistrées, de la CLI EB ou d' AWS CLI. Pour plus d’informations, consultez [Options de configuration](command-options.md).
# Configuration de commandes de démarrage personnalisées avec un Procfile Elastic Beanstalk
Vous pouvez inclure un fichier appelé `Procfile` à la racine de votre offre groupée source pour spécifier la commande qui démarre votre application.
**Example Procfile**
```
web: node index.js
```
Pour plus d'informations sur `Procfile` l'utilisation, voir[Buildfile et Procfile](platforms-linux-extend.build-proc.md).
**Note**
Cette fonctionnalité remplace l'option héritée `NodeCommand` dans l'espace de noms `aws:elasticbeanstalk:container:nodejs`.
# Configuration des dépendances de votre application sur Elastic Beanstalk
Votre application peut avoir des dépendances sur certains modules Node.js, comme ceux que vous spécifiez dans les instructions `require()`. Ces modules sont stockés dans un répertoire `node_modules`. Lorsque votre application s'exécute, Node.js charge les modules depuis ce répertoire. Pour en savoir plus, consultez [Loading from node\$1modules folders](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders) (Chargement depuis les dossiers node\$1modules) dans la documentation Node.js.
Vous pouvez spécifier ces dépendances de module à l'aide d'un fichier `package.json`. Si Elastic Beanstalk détecte ce fichier et qu'aucun répertoire `node_modules` n'est présent, Elastic Beanstalk exécute `npm install` en tant qu'utilisateur *webapp*. La commande `npm install` installe les dépendances dans le répertoire `node_modules` créé au préalable par Elastic Beanstalk. La commande `npm install` accède aux packages répertoriés dans le fichier `package.json` à partir du registre public npm ou d'autres emplacements. Pour en savoir plus, consultez le site Web [npm Docs](https://docs.npmjs.com/about-the-public-npm-registry).
Si Elastic Beanstalk détecte le répertoire `node_modules`, Elastic Beanstalk ne s'exécute pas `npm install`, même si un fichier `package.json` existe. Elastic Beanstalk part du principe que les packages de dépendance sont disponibles dans le répertoire`node_modules` pour Node.js à des fins d'accès et de chargement.
Les sections suivantes fournissent des informations supplémentaires sur la définition des dépendances de modules Node.js pour votre application.
**Note**
Si vous rencontrez des problèmes de déploiement lors de l'exécution d'Elastic Beanstalk `npm install`, envisagez une autre approche. Incluez le répertoire `node_modules` avec les modules de dépendance dans l’offre groupée source de votre application. Cela peut contourner les problèmes liés à l'installation de dépendances à partir du registre public npm pendant que vous étudiez le problème. Comme les modules de dépendance proviennent d'un répertoire local, cela peut également contribuer à réduire le temps de déploiement. Pour de plus amples informations, consultez [Inclusion des dépendances Node.js dans un répertoire node\$1modules](#nodejs-platform-nodemodules).
## Spécification des dépendances Node.js avec un fichier package.json
Utilisez un fichier `package.json` à la racine de votre source de projet pour spécifier des packages de dépendance et pour fournir une commande start. Lorsqu'un fichier `package.json` est présent et qu'aucun répertoire `node_modules` n'est présent à la racine de la source de votre projet, Elastic Beanstalk exécute `npm install` en tant qu'utilisateur *webapp* pour installer les dépendances à partir du registre public npm. Il utilise également la commande `start` pour démarrer votre application. Pour en savoir plus sur le fichier `package.json`, consultez la section [Définition des dépendances dans un fichier `package.json`](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file) sur le site Web de *npm Docs*.
Utilisez le mot-clé `scripts` pour fournir une commande start. Le mot-clé `scripts` est maintenant utilisé à la place de l'option héritée `NodeCommand` dans l'espace de noms `aws:elasticbeanstalk:container:nodejs`.
**Example package.json – Express**
```
{
"name": "my-app",
"version": "0.0.1",
"private": true,
"dependencies": {
"ejs": "latest",
"aws-sdk": "latest",
"express": "latest",
"body-parser": "latest"
},
"scripts": {
"start": "node app.js"
}
}
```
**Mode production et dépendances dev**
Pour spécifier vos dépendances dans le fichier `package.json`, utilisez les attributs *dependencies* et *devDependencies*. L'attribut *dependencies* désigne les packages nécessaires à votre application en production. L'attribut *devDependencies* désigne les packages qui ne sont nécessaires que pour le développement local et les tests.
Si vous devez installer les packages *devDependencies*, définissez la propriété d'environnement NPM\$1USE\$1PRODUCTION sur `false`. Avec ce paramètre, nous n'utiliserons pas les options ci-dessus lors de l'exécution de npm install. Ainsi, les packages *devDependencies* seront installés.
## Inclusion des dépendances Node.js dans un répertoire node\$1modules
Pour déployer les packages de dépendances sur des instances d'environnement avec votre code d'application, incluez-les dans un répertoire nommé `node_modules` à la racine de la source de votre projet. Pour en savoir plus, consultez la section [Téléchargement et installation de packages localement sur](https://docs.npmjs.com/downloading-and-installing-packages-locally) le site Web de *npm Docs*.
[Lorsque vous déployez un `node_modules` répertoire dans une version AL2023/AL2 Node.jsplatform, Elastic Beanstalk part du principe que vous fournissez vos propres packages de dépendances et évite d'installer les dépendances spécifiées dans un fichier package.json.](#nodejs-platform-packagejson) Node.jsrecherche les dépendances dans le `node_modules` répertoire. Pour en savoir plus, consultez la section [Chargement à partir des dossiers node\$1modules](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders) dans la documentation Node.js.
**Note**
Si vous rencontrez des problèmes de déploiement lors de l'exécution d'Elastic Beanstalk `npm install`, pensez à utiliser l'approche décrite dans cette rubrique pour contourner le problème pendant que vous étudiez le problème.
### Considérations relatives à Node.js sur Amazon Linux 2
Lisez cette section si vous utilisez une branche de plateforme *Node.js* exécutée sur *Amazon Linux 2*.
#### Considérations relatives à Node.js sur Amazon Linux 2
**Note**
Les informations contenues dans cette rubrique s'appliquent aux branches de Node.js plate-forme exécutées sur Amazon Linux 2. Le contenu décrit ici AL2 des fonctionnalités et des comportements spécifiques qui diffèrent de AL2023.
**Variations de commande**
Les options de commande varient en fonction de la version de npm incluse dans la branche de plate-forme Amazon Linux 2 sur laquelle votre application s'exécute.
+ npm v6 – Elastic Beanstalk installe les dépendances en mode production par défaut. Il utilise la commande `npm install --production`.
+ npm v7 ou ultérieure – Elastic Beanstalk omet les *devDependencies*. Il utilise la commande `npm install --omit=dev`.
Les deux commandes listées ci-dessus n'installent pas les packages qui sont des *devDependencies*.
**Protocoles SSH et HTTPS pour les dépendances Git**
À compter de la sortie de la plateforme Amazon Linux 2 du 7 mars 2023, vous pouvez utiliser les protocoles SSH et HTTPS pour récupérer des packages depuis un référentiel Git. La branche de plateforme Node.js 16 prend en charge les protocoles SSH et HTTPS. La branche Node.js 14 ne prend en charge que le protocole HTTPS.
**Example package.json – Node.js 16 prend en charge les protocoles HTTPS et SSH**
```
...
"dependencies": {
"aws-sdk": "https://github.com/aws/aws-sdk-js.git",
"aws-chime": "git+ssh://git@github.com:aws/amazon-chime-sdk-js.git"
}
```
**Versions et plages de versions**
Utilisez le mot-clé `engines` du fichier `package.json` pour spécifier la version de Node.js que vous souhaitez que votre application utilise. Vous pouvez également spécifier une plage de versions à l'aide de la notation npm. Pour en savoir plus sur la syntaxe des plages de versions, consultez la section [Gestion sémantique des versions à l'aide de npm](https://nodejs.dev/learn/semantic-versioning-using-npm) sur le site web de Node.js. Le mot-clé `engines` du fichier Node.js `package.json` remplace l'option `NodeVersion` héritée dans l'espace de noms `aws:elasticbeanstalk:container:nodejs`.
**Important**
La fonctionnalité permettant de spécifier des plages de versions n'est pas disponible pour les branches de la plateforme Node.js exécutées sur AL2023. Nous ne prenons en charge qu'une seule version de Node.js au sein d'une branche Node.js spécifique sur AL2023. Si votre fichier `package.json` spécifie une plage de versions, nous l'ignorerons et utiliserons par défaut la version de la branche de plateforme de Node.js.
**Example `package.json` - Version Node.js unique**
```
{
...
"engines": { "node" : "14.16.0" }
}
```
**Example `package.json` - Gamme de versions Node.js**
```
{
...
"engines": { "node" : ">=10 <11" }
}
```
Lorsqu'une plage de versions est indiquée, Elastic Beanstalk installe la dernière version de Node.js à la disposition de la plateforme dans cette plage. Dans cet exemple, la plage indique que la version doit être supérieure ou égale à la version 10, mais inférieure à la version 11. Par conséquent, Elastic Beanstalk installe la dernière version Node.js de 10.x.y, disponible sur la [plateforme prise en charge](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs).
Sachez que vous ne pouvez spécifier qu'une version de Node.js qui correspond à votre branche de plateforme. Par exemple, si vous utilisez la branche de plateforme Node.js 16, vous ne pouvez spécifier qu'une version 16.x.y de Node.js. Vous pouvez utiliser les options de plage de versions prises en charge par npm pour offrir plus de flexibilité. Pour les versions Node.js valides pour chaque branche de plateforme, consultez [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) dans le guide *Plateformes AWS Elastic Beanstalk *.
**Note**
Lorsque la prise en charge de la version de Node.js que vous utilisez est supprimée de la plateforme, vous devez modifier ou supprimer le paramètre de version de Node.js avant de procéder à une [mise à jour de la plateforme](using-features.platform.upgrade.md). Cela peut se produire lorsqu'une faille de sécurité est identifiée pour une ou plusieurs versions de Node.js
Lorsque cela se produit, toute tentative de mise à jour vers une nouvelle version de la plateforme qui ne prend pas en charge la version Node.js configurée échoue. Pour éviter de créer un nouvel environnement, modifiez le paramètre de version de Node.js dans `package.json` sur une version de Node.js qui est prise en charge à la fois par l'ancienne version de la plateforme et par la nouvelle. Vous avez la possibilité de spécifier une plage de versions Node.js qui inclut une version prise en charge, comme décrit plus haut dans cette rubrique. Vous pouvez également supprimer le paramètre, puis déployer le nouveau bundle source.
# Verrouiller les dépendances avec npm shrinkwrap Elastic Beanstalk
La plateforme Node.js exécute `npm install` en tant qu'utilisateur *webapp* lors de chaque déploiement. Lorsque de nouvelles versions de vos dépendances sont disponibles, elles sont installées lorsque vous déployez l'application, ce qui peut ralentir de manière significative le déploiement.
Pour éviter la mise à jour des dépendances, il est possible de créer un fichier `npm-shrinkwrap.json` qui verrouille les dépendances de votre application sur la version actuelle.
```
$ npm install
$ npm shrinkwrap
wrote npm-shrinkwrap.json
```
Incluez ce fichier dans votre bundle de fichiers source afin que les dépendances ne soient installées qu'à une seule reprise.
# Configuration du serveur proxy
Elastic Beanstalk utilise NGINX ou Apache HTTPD comme proxy inverse pour mapper votre application à votre équilibreur de charge Elastic Load Balancing sur le port 80. La valeur par défaut est NGINX. Elastic Beanstalk fournit une configuration de proxy par défaut que vous pouvez étendre ou remplacer totalement par votre propre configuration.
Par défaut, Elastic Beanstalk configure le serveur proxy pour transmettre les demandes à votre application sur le port 5 000. Vous pouvez remplacer le port par défaut en définissant la `PORT`[propriété d'environnement](create_deploy_nodejs.container.md#nodejs-platform-console) sur le port écouté par votre application.
**Note**
Le port que votre application écoute n'affecte pas le port que le serveur NGINX écoute pour recevoir des demandes de l'équilibreur de charge.
**Configuration du serveur proxy sur la version de votre plateforme**
Toutes les AL2 plateformes AL2023/prennent en charge une fonctionnalité de configuration de proxy uniforme. Pour plus d'informations sur la configuration du serveur proxy sur les versions de votre plate-forme exécutant AL2023/AL2, consultez[Configuration du proxy inverse](platforms-linux-extend.proxy.md).
## Configuration du proxy sur l'AMI Amazon Linux (antérieure à Amazon Linux 2)
Si votre environnement Elastic Beanstalk Node.js utilise une version de plateforme Amazon Linux AMI (antérieure à Amazon Linux 2), lisez les informations de cette section.
**Remarques**
Les informations de cette rubrique s'appliquent uniquement aux branches de plate-forme basées sur l'AMI Amazon Linux (AL1). AL2023Les branches/AL2 platform sont incompatibles avec les versions précédentes de la plateforme Amazon Linux AMI (AL1) et *nécessitent des paramètres de configuration différents*.
[Le 18 juillet 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk a défini le statut de toutes les branches de la plateforme sur la base de l'AMI AL1 Amazon Linux () comme étant supprimées.** Pour plus d'informations sur la migration vers une branche de plateforme Amazon Linux 2023 actuelle et entièrement prise en charge, consultez [Migration de votre application Elastic Beanstalk Linux vers Amazon Linux 2023 ou Amazon Linux 2](using-features.migration-al.md).
### Extension et remplacement de la configuration du proxy par défaut — Amazon Linux AMI () AL1
La plateforme Node.js utilise un proxy inverse pour acheminer les requêtes du port 80 de l'instance vers le port 8081 d'écoute de votre application. Elastic Beanstalk fournit une configuration de proxy par défaut que vous pouvez étendre ou remplacer totalement par votre propre configuration.
Pour étendre la configuration par défaut, ajoutez des fichiers `.conf` à `/etc/nginx/conf.d` avec un fichier de configuration. Pour un exemple spécifique, veuillez consulter [Suspension des connexions HTTPS sur des instances EC2 exécutant Node.js](https-singleinstance-nodejs.md).
La plateforme Node.js définit la variable d'environnement PORT sur le port vers lequel le serveur proxy transfère le trafic. Lisez cette variable dans votre code pour configurer le port de votre application.
```
var port = process.env.PORT || 3000;
var server = app.listen(port, function () {
console.log('Server running at http://127.0.0.1:' + port + '/');
});
```
La configuration NGINX par défaut achemine le trafic vers un serveur en amont nommé `nodejs` à l'adresse `127.0.0.1:8081`. Vous pouvez supprimer la configuration par défaut et fournir une configuration personnalisée dans un [fichier de configuration](ebextensions.md).
**Example .ebextensions/proxy.config**
L'exemple suivant supprime la configuration par défaut et ajoute une configuration personnalisée qui achemine le trafic vers le port 5000 au lieu du port 8081.
```
files:
/etc/nginx/conf.d/proxy.conf:
mode: "000644"
owner: root
group: root
content: |
upstream nodejs {
server 127.0.0.1:5000;
keepalive 256;
}
server {
listen 8080;
if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
set $year $1;
set $month $2;
set $day $3;
set $hour $4;
}
access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd;
access_log /var/log/nginx/access.log main;
location / {
proxy_pass http://nodejs;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
gzip on;
gzip_comp_level 4;
gzip_types text/html text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
location /static {
alias /var/app/current/static;
}
}
/opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh:
mode: "000755"
owner: root
group: root
content: |
#!/bin/bash -xe
rm -f /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf
service nginx stop
service nginx start
container_commands:
removeconfig:
command: "rm -f /tmp/deployment/config/#etc#nginx#conf.d#00_elastic_beanstalk_proxy.conf /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf"
```
L'exemple de configuration (`/etc/nginx/conf.d/proxy.conf`) utilise la configuration par défaut dans `/etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf` comme base pour inclure le bloc de serveur par défaut avec des paramètres de compression et de journalisation et un mappage de fichiers statiques.
La commande `removeconfig` supprime la configuration par défaut du conteneur pour que le serveur proxy utilise bien la configuration personnalisée. Elastic Beanstalk recrée la configuration par défaut lorsque chaque configuration est déployée. Pour tenir compte de cela, dans l'exemple suivant, un post-configuration-deployment hook (`/opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh`) est ajouté. Celui-ci supprime la configuration par défaut et redémarre le serveur proxy.
**Note**
Il est possible que la configuration par défaut change dans les prochaines versions de la plateforme Node.js. Utilisez la version la plus récente de la configuration comme base pour vos personnalisations afin de garantir leur compatibilité.
Si vous remplacez la configuration par défaut, vous devez définir les mappages de fichiers statiques et la compression GZIP. Cela s'explique par le fait que la plateforme ne peut pas appliquer les [paramètres standard](create_deploy_nodejs.container.md#nodejs-namespaces).
# Autres exemples d'applications et de didacticiels Elastic Beanstalk pour Node.js
Cette section fournit des applications et des didacticiels supplémentaires. La [QuickStart pour Node.js](nodejs-quickstart.md) rubrique présentée précédemment dans cette rubrique vous explique comment lancer l'exemple d'application Node.js avec l'interface de ligne de commande EB.
Pour commencer à utiliser les applications Node.js AWS Elastic Beanstalk, il vous suffit d'un [bundle de sources](applications-sourcebundle.md) d'applications à télécharger en tant que première version de l'application et à déployer dans un environnement.
## Lancement d'un environnement avec un exemple d'application Node.js
Elastic Beanstalk fournit des exemples d'applications d'une seule page pour chaque plate-forme, ainsi que des exemples plus complexes illustrant l'utilisation de ressources AWS supplémentaires telles qu'Amazon RDS et des fonctionnalités spécifiques au langage ou à la plate-forme et. APIs
**Note**
Suivez les étapes du fichier de la solution groupée source `README.md` pour le déployer.
**Exemples**
| Type d'environnement | Solution groupée source | Description |
| --- | --- | --- |
| Serveur web | [nodejs.zip](samples/nodejs.zip) | Application avec page unique. Pour lancer l'exemple d'application avec l'interface de ligne de commande EB, voir[QuickStart pour Node.js](nodejs-quickstart.md). Vous pouvez également utiliser la console Elastic Beanstalk pour lancer l'exemple d'application. Pour connaître les étapes détaillées, voir [Création d'un exemple d'application](GettingStarted.md#GettingStarted.CreateApp) dans le chapitre *Mise* en route de ce guide. |
| Serveur web avec Amazon RDS | [nodejs-example-express-rds.zip](samples/nodejs-example-express-rds.zip) | Application de journal de randonnée qui utilise le cadre Express et un service Amazon Relational Database Service (RDS). [Didacticiel](create_deploy_nodejs_express.md) |
| Serveur Web avec Amazon ElastiCache | [nodejs-example-express-elasticache.zip](samples/nodejs-example-express-elasticache.zip) | Application Web Express qui utilise Amazon ElastiCache pour le clustering. La mise en cluster permet d'améliorer la haute disponibilité, les performances et la sécurité de votre application web. [Didacticiel](nodejs-express-clustering.md) |
| Serveur web avec DynamoDB, Amazon SNS et Amazon SQS | [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) | Site web Express qui collecte les informations de contact des utilisateurs pour la nouvelle campagne de marketing d'une entreprise. Utilise le AWS SDK pour JavaScript in Node.js pour écrire des entrées dans une table DynamoDB, et les fichiers de configuration Elastic Beanstalk pour créer des ressources dans DynamoDB, Amazon SNS et Amazon SQS. [Didacticiel](nodejs-dynamodb-tutorial.md) |
## Étapes suivantes
Une fois que vous disposez d'un environnement exécutant une application, vous pouvez déployer une nouvelle version de l'application ou une application totalement différente à tout moment. Le déploiement d'une nouvelle version d'application est très rapide, car il n'est pas nécessaire de mettre en service ni de redémarrer les instances EC2. Pour plus d'informations sur le déploiement d'applications, voir [Déploiement d'une nouvelle version de votre application](GettingStarted.md#GettingStarted.DeployApp).
Une fois que vous avez déployé un ou deux exemples d'applications et que vous êtes prêt à commencer à développer et à exécuter des applications Node.js localement, consultez la section relative [Configuration de votre environnement de développement Node.js pour Elastic Beanstalk](nodejs-devenv.md) à la configuration d'un environnement de développement Node.js avec tous les outils dont vous aurez besoin.
# Déploiement d'une application Node.js Express sur Elastic Beanstalk
[Cette section explique comment déployer un exemple d'application sur Elastic Beanstalk à l'aide de l'interface de ligne de commande Elastic Beanstalk (EB CLI), puis comment mettre à jour l'application pour utiliser le framework Express.](http://expressjs.com/)
## Conditions préalables
Ce tutoriel nécessite les prérequis suivants :
+ Les exécutions Node.js
+ Le logiciel de gestion des packages Node.js par défaut, npm
+ Le générateur de ligne de commande Express
+ Interface de ligne de commande Elastic Beanstalk (EB)
Pour plus d'informations sur l'installation des trois premiers composants et la configuration de votre environnement de développement local, consultez [Configuration de votre environnement de développement Node.js pour Elastic Beanstalk](nodejs-devenv.md). Pour ce didacticiel, il n'est pas nécessaire d'installer le AWS SDK pour Node.js, qui est également mentionné dans la rubrique référencée.
Pour plus d'informations sur l'installation et la configuration de l'EB CLI, consultez [Installation de la CLI EB avec un script de configuration (recommandé)](eb-cli3.md#eb-cli3-install) et [Configuration de l'interface de ligne de commande EB](eb-cli3-configuration.md).
## Créer un environnement Elastic Beanstalk
**Votre répertoire d'application**
Ce tutoriel utilise un répertoire appelé `nodejs-example-express-rds` pour la création de la solution groupée de l'application. Créez le répertoire `nodejs-example-express-rds` pour ce tutoriel.
```
~$ mkdir nodejs-example-express-rds
```
**Note**
Chaque tutoriel de ce chapitre utilise son propre répertoire pour la solution groupée de l'application. Le nom du répertoire correspond au nom de l'exemple d'application utilisé par le tutoriel.
Changez votre répertoire de travail actuel vers `nodejs-example-express-rds`.
```
~$ cd nodejs-example-express-rds
```
Configurons maintenant un environnement Elastic Beanstalk exécutant la plateforme Node.js et l'exemple d'application. Nous utiliserons l'interface de ligne de commande Elastic Beanstalk (EB CLI).
**Pour configurer un référentiel de l'EB CLI pour votre application et créer un environnement Elastic Beanstalk qui exécute la plateforme Node.js**
1. Créez un référentiel à l'aide de la commande **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-express-rds$ eb init --platform node.js --region
```
Cette commande crée un fichier de configuration dans un dossier nommé `.elasticbeanstalk` qui spécifie les paramètres de création d'environnements pour votre application et crée une application Elastic Beanstalk dont le nom est basé sur le dossier actif.
1. Créez un environnement qui exécute un exemple d'application à l'aide de la commande **[**eb create**](eb3-create.md)**.
```
~/nodejs-example-express-rds$ eb create --sample nodejs-example-express-rds
```
Cette commande crée un environnement à charge équilibrée avec les paramètres par défaut de la plateforme Node.js et les ressources suivantes :
+ **EC2 instance** — Une machine virtuelle Amazon Elastic Compute Cloud (Amazon EC2) configurée pour exécuter des applications Web sur la plateforme de votre choix.
Chaque plateforme exécute un ensemble spécifique de logiciels, de fichiers de configuration et de scripts pour prendre en charge une version de langage, une infrastructure ou un conteneur web spécifiques, ou une combinaison de ces éléments. La plupart des plateformes utilisent Apache ou nginx comme proxy inverse situé devant votre application web, qui lui transmet des demandes, traite des ressources statiques et génère des journaux d'accès et d'erreur.
+ **Groupe de sécurité d'instance** : groupe EC2 de sécurité Amazon configuré pour autoriser le trafic entrant sur le port 80. Cette ressource permet au trafic HTTP provenant de l'équilibreur de charge d'atteindre l' EC2 instance qui exécute votre application Web. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **Équilibreur de charge** – Équilibreur de charge Elastic Load Balancing configuré pour répartir les demandes vers les instances exécutant votre application. De plus, l'équilibreur de charge vous évite d'exposer directement vos instances sur Internet.
+ Groupe de **sécurité d'équilibrage de charge : groupe** EC2 de sécurité Amazon configuré pour autoriser le trafic entrant sur le port 80. Cette ressource autorise le trafic HTTP provenant d'Internet à atteindre l'équilibreur de charge. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **Groupe Auto Scaling** – Groupe Auto Scaling configuré pour remplacer une instance si elle est résiliée ou devient indisponible.
+ **Compartiment Amazon S3** – Emplacement de stockage pour votre code source, les journaux et autres artefacts qui sont créés lorsque vous utilisez Elastic Beanstalk.
+ ** CloudWatch Alarmes Amazon** : deux CloudWatch alarmes qui surveillent la charge sur les instances de votre environnement et qui sont déclenchées si la charge est trop élevée ou trop faible. Lorsqu'une alarme est déclenchée, votre groupe Auto Scaling s'adapte en fonction, à la hausse ou à la baisse.
+ **CloudFormation stack** : Elastic CloudFormation Beanstalk utilise pour lancer les ressources de votre environnement et propager les modifications de configuration. Les ressources sont définies dans un modèle, que vous pouvez afficher dans la [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nom de domaine** : nom de domaine qui permet d'accéder à votre application Web dans le formulaire **subdomain*. *region*.elasticbeanstalk.com*.
**Sécurité du domaine**
Pour renforcer la sécurité de vos applications Elastic Beanstalk, le domaine *elasticbeanstalk.com* est enregistré dans la [liste des suffixes publics (PSL)](https://publicsuffix.org/).
Si vous devez définir des cookies sensibles dans le nom de domaine par défaut de vos applications Elastic Beanstalk, nous vous recommandons d'utiliser des cookies `__Host-` avec un préfixe pour une sécurité accrue. Cette pratique protège votre domaine contre les tentatives de falsification de requêtes intersites (CSRF). Pour plus d'informations, consultez la page [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) du Mozilla Developer Network.
1. Une fois l'environnement créé, utilisez la commande [**eb open**](eb3-open.md) pour ouvrir l'URL de l'environnement dans le navigateur par défaut.
```
~/nodejs-example-express-rds$ eb open
```
Vous avez maintenant créé un environnement Node.js Elastic Beanstalk avec un exemple d'application. Vous pouvez le mettre à jour avec votre propre application. Ensuite, nous mettons à jour l'exemple d'application afin d'utiliser l'infrastructure Express.
## Mise à jour de l'application pour utiliser Express
Une fois que vous avez créé un environnement avec un exemple d'application, vous pouvez le mettre à jour à l'aide de votre propre application. Dans cette procédure, nous exécutons d'abord les commandes **express** et **npm install** pour configurer le cadre Express dans votre répertoire d'application. Nous utilisons ensuite la EB CLI pour mettre à jour votre environnement Elastic Beanstalk avec l'application mise à jour.
**Pour mettre à jour votre application afin d'utiliser Express**
1. Exécutez la commande `express`. Il en résulte la génération de `package.json`, `app.js`, et de quelques répertoires.
```
~/nodejs-example-express-rds$ express
```
Lorsque vous êtes invité à continuer, tapez **y**.
**Note**
Si la commande **express** ne fonctionne pas, il se peut que vous n'ayez pas installé le générateur de ligne de commande Express, comme décrit dans la section précédente sur les *prérequis*. Il se peut également que le chemin d'accès au répertoire de votre ordinateur local doive être configuré pour permettre l'exécution de la commande **express**. Consultez la section *Prérequis* pour connaître les étapes détaillées de la configuration de votre environnement de développement, afin de pouvoir poursuivre ce tutoriel.
1. Configurez les dépendances locales.
```
~/nodejs-example-express-rds$ npm install
```
1. (Facultatif) Vérifiez que le serveur de l'application web démarre.
```
~/nodejs-example-express-rds$ npm start
```
Vous devez voir des résultats similaires à ce qui suit :
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
Par défaut, le serveur s'exécute sur le port 3000. Pour le tester, exécutez `curl http://localhost:3000` sur un autre terminal, ou ouvrez un navigateur sur l'ordinateur local et entrez l'adresse URL `http://localhost:3000`.
Appuyez sur **Ctrl\$1C** afin d'arrêter le serveur.
1. Déployez les modifications dans votre environnement Elastic Beanstalk avec la commande [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-rds$ eb deploy
```
1. Une fois que votre environnement est prêt (il apparaît en vert), actualisez l'URL pour vérifier si l'opération a fonctionné. Une page web intitulée **Welcome to Express** doit s'afficher.
Ensuite, nous devons mettre à jour l'application Express afin de traiter les fichiers statiques et d'ajouter une nouvelle page.
**Pour configurer les fichiers statiques et ajouter une nouvelle page à votre application Express**
1. Ajoutez un deuxième fichier de configuration dans le dossier [`.ebextensions`](ebextensions.md) avec le contenu suivant :
**`nodejs-example-express-rds/.ebextensions/staticfiles.config`**
```
option_settings:
aws:elasticbeanstalk:environment:proxy:staticfiles:
/stylesheets: public/stylesheets
```
Ce paramètre configure le serveur proxy afin qu'il transmette les fichiers du dossier `public` au chemin `/public` de l'application. La distribution de fichiers de manière statique depuis le serveur proxy réduit la charge sur votre application. Pour plus d'informations, consultez [Fichiers statiques](create_deploy_nodejs.container.md#nodejs-platform-console-staticfiles) plus haut dans ce chapitre.
1. (Facultatif) Pour confirmer que les mappages statiques sont correctement configurés, commentez la configuration du mappage statique dans `nodejs-example-express-rds/app.js`. Cela supprime le mappage de l'application node.
```
// app.use(express.static(path.join(__dirname, 'public')));
```
Les mappages de fichiers statiques dans le fichier `staticfiles.config` de l'étape précédente devraient toujours charger la feuille de style avec succès, même après avoir commenté cette ligne. Pour vérifier que les mappages de fichiers statiques sont chargés via la configuration de fichiers statiques du proxy, plutôt que via l'application express, supprimez les valeurs qui suivent `option_settings:`. Une fois qu'elle a été supprimée de la configuration des fichiers statiques et de l'application node, la feuille de style ne se chargera pas.
N'oubliez pas de réinitialiser le contenu des fichiers `nodejs-example-express-rds/app.js` et `staticfiles.config` lorsque vous avez terminé vos tests.
1. Addition `nodejs-example-express-rds/routes/hike.js`. Saisissez les données ci-dessous :
```
exports.index = function(req, res) {
res.render('hike', {title: 'My Hiking Log'});
};
exports.add_hike = function(req, res) {
};
```
1. Mettez à jour `nodejs-example-express-rds/app.js` en y incluant trois nouvelles lignes.
Commencez par ajouter la ligne suivante afin d'ajouter un `require` pour cette route :
```
var hike = require('./routes/hike');
```
Votre fichier doit être similaire à l'extrait suivant :
```
var express = require('express');
var path = require('path');
var hike = require('./routes/hike');
```
Ajoutez ensuite les deux lignes suivantes au fichier `nodejs-example-express-rds/app.js` après `var app = express();`
```
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
```
Votre fichier doit être similaire à l'extrait suivant :
```
var app = express();
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
```
1. Copiez `nodejs-example-express-rds/views/index.jade` dans `nodejs-example-express-rds/views/hike.jade`.
```
~/nodejs-example-express-rds$ cp views/index.jade views/hike.jade
```
1. Déployez les modifications avec la commande [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-rds$ eb deploy
```
1. Votre environnement est mis à jour au bout de quelques minutes. Une fois que votre environnement est prêt (il apparaît en vert), assurez-vous qu'il fonctionne. Pour ce faire, actualisez la page de votre navigateur et ajoutez **hikes** à la fin de l'URL (par exemple, `http://node-express-env-syypntcz2q.elasticbeanstalk.com/hikes`).
Vous devriez voir une page web intitulée **My Hiking Log**.
Vous avez maintenant créé une application web qui utilise le cadre Express. Dans la section suivante, nous allons modifier l'application pour qu'elle utilise un service de base de données relationnelle Amazon (RDS) afin de stocker un journal de randonnée.
## Mise à jour de l'application pour utiliser Amazon RDS
Dans l'étape suivante, nous mettons à jour l'application pour qu'elle utilise Amazon RDS for MySQL.
**Pour mettre à jour votre application afin d'utiliser RDS for MySQL**
1. Pour créer une base de données RDS for MySQL associée à votre environnement Elastic Beanstalk, suivez les instructions de la rubrique [Ajout d'une base de données](create-deploy-nodejs.rds.md) incluse plus loin dans ce chapitre. L'ajout d'une instance de base de données prend environ 10 minutes.
1. Mettez à jour la section des dépendances dans `package.json` avec le contenu suivant :
```
"dependencies": {
"async": "^3.2.4",
"express": "4.18.2",
"jade": "1.11.0",
"mysql": "2.18.1",
"node-uuid": "^1.4.8",
"body-parser": "^1.20.1",
"method-override": "^3.0.0",
"morgan": "^1.10.0",
"errorhandler": "^1.5.1"
}
```
1. Exécutez **npm install**.
```
~/nodejs-example-express-rds$ npm install
```
1. Mettez à jour `app.js` pour vous connecter à la base de données, créer une table et insérer un journal de randonnée unique par défaut. Chaque fois que cette application sera déployée, elle supprimera la table des randonnées précédente et la recréera.
```
/**
* Module dependencies.
*/
const express = require('express')
, routes = require('./routes')
, hike = require('./routes/hike')
, http = require('http')
, path = require('path')
, mysql = require('mysql')
, async = require('async')
, bodyParser = require('body-parser')
, methodOverride = require('method-override')
, morgan = require('morgan')
, errorhandler = require('errorhandler');
const { connect } = require('http2');
const app = express()
app.set('views', __dirname + '/views')
app.set('view engine', 'jade')
app.use(methodOverride())
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))
app.use(express.static(path.join(__dirname, 'public')))
app.set('connection', mysql.createConnection({
host: process.env.RDS_HOSTNAME,
user: process.env.RDS_USERNAME,
password: process.env.RDS_PASSWORD,
port: process.env.RDS_PORT}));
function init() {
app.get('/', routes.index);
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
}
const client = app.get('connection');
async.series([
function connect(callback) {
client.connect(callback);
console.log('Connected!');
},
function clear(callback) {
client.query('DROP DATABASE IF EXISTS mynode_db', callback);
},
function create_db(callback) {
client.query('CREATE DATABASE mynode_db', callback);
},
function use_db(callback) {
client.query('USE mynode_db', callback);
},
function create_table(callback) {
client.query('CREATE TABLE HIKES (' +
'ID VARCHAR(40), ' +
'HIKE_DATE DATE, ' +
'NAME VARCHAR(40), ' +
'DISTANCE VARCHAR(40), ' +
'LOCATION VARCHAR(40), ' +
'WEATHER VARCHAR(40), ' +
'PRIMARY KEY(ID))', callback);
},
function insert_default(callback) {
const hike = {HIKE_DATE: new Date(), NAME: 'Hazard Stevens',
LOCATION: 'Mt Rainier', DISTANCE: '4,027m vertical', WEATHER:'Bad', ID: '12345'};
client.query('INSERT INTO HIKES set ?', hike, callback);
}
], function (err, results) {
if (err) {
console.log('Exception initializing database.');
throw err;
} else {
console.log('Database initialization complete.');
init();
}
});
module.exports = app
```
1. Ajoutez le contenu suivant à `routes/hike.js`. Cela permettra aux acheminements d'insérer de nouveaux journaux de randonnée dans la base de données *HIKES*.
```
const uuid = require('node-uuid');
exports.index = function(req, res) {
res.app.get('connection').query( 'SELECT * FROM HIKES', function(err,
rows) {
if (err) {
res.send(err);
} else {
console.log(JSON.stringify(rows));
res.render('hike', {title: 'My Hiking Log', hikes: rows});
}});
};
exports.add_hike = function(req, res){
const input = req.body.hike;
const hike = { HIKE_DATE: new Date(), ID: uuid.v4(), NAME: input.NAME,
LOCATION: input.LOCATION, DISTANCE: input.DISTANCE, WEATHER: input.WEATHER};
console.log('Request to log hike:' + JSON.stringify(hike));
req.app.get('connection').query('INSERT INTO HIKES set ?', hike, function(err) {
if (err) {
res.send(err);
} else {
res.redirect('/hikes');
}
});
};
```
1. Remplacez le contenu de `routes/index.js` par ce qui suit :
```
/*
* GET home page.
*/
exports.index = function(req, res){
res.render('index', { title: 'Express' });
};
```
1. Ajoutez le modèle jade suivant à `views/hike.jade` pour fournir l'interface utilisateur permettant d'ajouter des journaux de randonnée.
```
extends layout
block content
h1= title
p Welcome to #{title}
form(action="/add_hike", method="post")
table(border="1")
tr
td Your Name
td
input(name="hike[NAME]", type="textbox")
tr
td Location
td
input(name="hike[LOCATION]", type="textbox")
tr
td Distance
td
input(name="hike[DISTANCE]", type="textbox")
tr
td Weather
td
input(name="hike[WEATHER]", type="radio", value="Good")
| Good
input(name="hike[WEATHER]", type="radio", value="Bad")
| Bad
input(name="hike[WEATHER]", type="radio", value="Seattle", checked)
| Seattle
tr
td(colspan="2")
input(type="submit", value="Record Hike")
div
h3 Hikes
table(border="1")
tr
td Date
td Name
td Location
td Distance
td Weather
each hike in hikes
tr
td #{hike.HIKE_DATE.toDateString()}
td #{hike.NAME}
td #{hike.LOCATION}
td #{hike.DISTANCE}
td #{hike.WEATHER}
```
1. Déployez les modifications avec la commande [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-rds$ eb deploy
```
## Nettoyage
Si vous avez terminé de travailler avec Elastic Beanstalk, vous pouvez résilier votre environnement.
Utilisez la commande **eb terminate** pour suspendre votre environnement et toutes les ressources qu'il contient.
```
~/nodejs-example-express-rds$ eb terminate
The environment "nodejs-example-express-rds-env" and all associated instances will be terminated.
To confirm, type the environment name: nodejs-example-express-rds-env
INFO: terminateEnvironment is starting.
...
```
# Déploiement d'une application Node.js Express avec clustering sur Elastic Beanstalk
[http://expressjs.com/](http://expressjs.com/) La mise en cluster permet d'améliorer la haute disponibilité, les performances et la sécurité de votre application web. Pour en savoir plus sur Amazon ElastiCache, rendez-vous sur [Qu'est-ce qu'Amazon ElastiCache (Memcached](https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/Introduction.html)) ? dans le guide de l'*utilisateur d'Amazon ElastiCache (Memcached)*.
**Note**
Cet exemple crée AWS des ressources qui peuvent vous être facturées. Pour plus d'informations sur la AWS tarification, consultez[https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/). Certains services font partie du niveau d'utilisation AWS gratuit. Si vous êtes un nouveau client, vous pouvez essayer ces services gratuitement. Pour plus d’informations, consultez [https://aws.amazon.com/free/](https://aws.amazon.com/free/).
## Conditions préalables
Ce tutoriel nécessite les prérequis suivants :
+ Les exécutions Node.js
+ Le logiciel de gestion des packages Node.js par défaut, npm
+ Le générateur de ligne de commande Express
+ Interface de ligne de commande Elastic Beanstalk (EB)
Pour plus d'informations sur l'installation des trois premiers composants et la configuration de votre environnement de développement local, consultez [Configuration de votre environnement de développement Node.js pour Elastic Beanstalk](nodejs-devenv.md). Pour ce didacticiel, il n'est pas nécessaire d'installer le AWS SDK pour Node.js, qui est également mentionné dans la rubrique référencée.
Pour plus d'informations sur l'installation et la configuration de l'EB CLI, consultez [Installation de la CLI EB avec un script de configuration (recommandé)](eb-cli3.md#eb-cli3-install) et [Configuration de l'interface de ligne de commande EB](eb-cli3-configuration.md).
## Créer un environnement Elastic Beanstalk
**Votre répertoire d'application**
Ce tutoriel utilise un répertoire appelé `nodejs-example-express-elasticache` pour la création de la solution groupée de l'application. Créez le répertoire `nodejs-example-express-elasticache` pour ce tutoriel.
```
~$ mkdir nodejs-example-express-elasticache
```
**Note**
Chaque tutoriel de ce chapitre utilise son propre répertoire pour la solution groupée de l'application. Le nom du répertoire correspond au nom de l'exemple d'application utilisé par le tutoriel.
Changez votre répertoire de travail actuel vers `nodejs-example-express-elasticache`.
```
~$ cd nodejs-example-express-elasticache
```
Configurons maintenant un environnement Elastic Beanstalk exécutant la plateforme Node.js et l'exemple d'application. Nous utiliserons l'interface de ligne de commande Elastic Beanstalk (EB CLI).
**Pour configurer un référentiel de l'EB CLI pour votre application et créer un environnement Elastic Beanstalk qui exécute la plateforme Node.js**
1. Créez un référentiel à l'aide de la commande **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-express-elasticache$ eb init --platform node.js --region
```
Cette commande crée un fichier de configuration dans un dossier nommé `.elasticbeanstalk` qui spécifie les paramètres de création d'environnements pour votre application et crée une application Elastic Beanstalk dont le nom est basé sur le dossier actif.
1. Créez un environnement qui exécute un exemple d'application à l'aide de la commande **[**eb create**](eb3-create.md)**.
```
~/nodejs-example-express-elasticache$ eb create --sample nodejs-example-express-elasticache
```
Cette commande crée un environnement à charge équilibrée avec les paramètres par défaut de la plateforme Node.js et les ressources suivantes :
+ **EC2 instance** — Une machine virtuelle Amazon Elastic Compute Cloud (Amazon EC2) configurée pour exécuter des applications Web sur la plateforme de votre choix.
Chaque plateforme exécute un ensemble spécifique de logiciels, de fichiers de configuration et de scripts pour prendre en charge une version de langage, une infrastructure ou un conteneur web spécifiques, ou une combinaison de ces éléments. La plupart des plateformes utilisent Apache ou nginx comme proxy inverse situé devant votre application web, qui lui transmet des demandes, traite des ressources statiques et génère des journaux d'accès et d'erreur.
+ **Groupe de sécurité d'instance** : groupe EC2 de sécurité Amazon configuré pour autoriser le trafic entrant sur le port 80. Cette ressource permet au trafic HTTP provenant de l'équilibreur de charge d'atteindre l' EC2 instance qui exécute votre application Web. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **Équilibreur de charge** – Équilibreur de charge Elastic Load Balancing configuré pour répartir les demandes vers les instances exécutant votre application. De plus, l'équilibreur de charge vous évite d'exposer directement vos instances sur Internet.
+ Groupe de **sécurité d'équilibrage de charge : groupe** EC2 de sécurité Amazon configuré pour autoriser le trafic entrant sur le port 80. Cette ressource autorise le trafic HTTP provenant d'Internet à atteindre l'équilibreur de charge. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **Groupe Auto Scaling** – Groupe Auto Scaling configuré pour remplacer une instance si elle est résiliée ou devient indisponible.
+ **Compartiment Amazon S3** – Emplacement de stockage pour votre code source, les journaux et autres artefacts qui sont créés lorsque vous utilisez Elastic Beanstalk.
+ ** CloudWatch Alarmes Amazon** : deux CloudWatch alarmes qui surveillent la charge sur les instances de votre environnement et qui sont déclenchées si la charge est trop élevée ou trop faible. Lorsqu'une alarme est déclenchée, votre groupe Auto Scaling s'adapte en fonction, à la hausse ou à la baisse.
+ **CloudFormation stack** : Elastic CloudFormation Beanstalk utilise pour lancer les ressources de votre environnement et propager les modifications de configuration. Les ressources sont définies dans un modèle, que vous pouvez afficher dans la [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nom de domaine** : nom de domaine qui permet d'accéder à votre application Web dans le formulaire **subdomain*. *region*.elasticbeanstalk.com*.
**Sécurité du domaine**
Pour renforcer la sécurité de vos applications Elastic Beanstalk, le domaine *elasticbeanstalk.com* est enregistré dans la [liste des suffixes publics (PSL)](https://publicsuffix.org/).
Si vous devez définir des cookies sensibles dans le nom de domaine par défaut de vos applications Elastic Beanstalk, nous vous recommandons d'utiliser des cookies `__Host-` avec un préfixe pour une sécurité accrue. Cette pratique protège votre domaine contre les tentatives de falsification de requêtes intersites (CSRF). Pour plus d'informations, consultez la page [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) du Mozilla Developer Network.
1. Une fois l'environnement créé, utilisez la commande [**eb open**](eb3-open.md) pour ouvrir l'URL de l'environnement dans le navigateur par défaut.
```
~/nodejs-example-express-elasticache$ eb open
```
Vous avez maintenant créé un environnement Node.js Elastic Beanstalk avec un exemple d'application. Vous pouvez le mettre à jour avec votre propre application. Ensuite, nous mettons à jour l'exemple d'application afin d'utiliser l'infrastructure Express.
## Mise à jour de l'application pour utiliser Express
Mettez à jour l'exemple d'application dans l'environnement Elastic Beanstalk pour utiliser le cadre Express.
Vous pouvez télécharger le code source final depuis le [nodejs-example-express-elasticachefichier .zip.](samples/nodejs-example-express-elasticache.zip)
**Pour mettre à jour votre application afin d'utiliser Express**
Une fois que vous avez créé un environnement avec un exemple d'application, vous pouvez le mettre à jour à l'aide de votre propre application. Dans cette procédure, nous exécutons d'abord les commandes **express** et **npm install** pour configurer le cadre Express dans votre répertoire d'application.
1. Exécutez la commande `express`. Il en résulte la génération de `package.json`, `app.js`, et de quelques répertoires.
```
~/nodejs-example-express-elasticache$ express
```
Lorsque vous êtes invité à continuer, tapez **y**.
**Note**
Si la commande **express** ne fonctionne pas, il se peut que vous n'ayez pas installé le générateur de ligne de commande Express, comme décrit dans la section précédente sur les *prérequis*. Il se peut également que le chemin d'accès au répertoire de votre ordinateur local doive être configuré pour permettre l'exécution de la commande **express**. Consultez la section *Prérequis* pour connaître les étapes détaillées de la configuration de votre environnement de développement, afin de pouvoir poursuivre ce tutoriel.
1. Configurez les dépendances locales.
```
~/nodejs-example-express-elasticache$ npm install
```
1. (Facultatif) Vérifiez que le serveur de l'application web démarre.
```
~/nodejs-example-express-elasticache$ npm start
```
Vous devez voir des résultats similaires à ce qui suit :
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
Par défaut, le serveur s'exécute sur le port 3000. Pour le tester, exécutez `curl http://localhost:3000` sur un autre terminal, ou ouvrez un navigateur sur l'ordinateur local et entrez l'adresse URL `http://localhost:3000`.
Appuyez sur **Ctrl\$1C** afin d'arrêter le serveur.
1. Renommez `nodejs-example-express-elasticache/app.js` en `nodejs-example-express-elasticache/express-app.js`.
```
~/nodejs-example-express-elasticache$ mv app.js express-app.js
```
1. Mettez à jour la ligne `var app = express();` dans `nodejs-example-express-elasticache/express-app.js` avec les éléments suivants :
```
var app = module.exports = express();
```
1. Sur votre ordinateur local, créez un fichier nommé `nodejs-example-express-elasticache/app.js` avec le code suivant.
```
/**
* Module dependencies.
*/
const express = require('express'),
session = require('express-session'),
bodyParser = require('body-parser'),
methodOverride = require('method-override'),
cookieParser = require('cookie-parser'),
fs = require('fs'),
filename = '/var/nodelist',
app = express();
let MemcachedStore = require('connect-memcached')(session);
function setup(cacheNodes) {
app.use(bodyParser.raw());
app.use(methodOverride());
if (cacheNodes.length > 0) {
app.use(cookieParser());
console.log('Using memcached store nodes:');
console.log(cacheNodes);
app.use(session({
secret: 'your secret here',
resave: false,
saveUninitialized: false,
store: new MemcachedStore({ 'hosts': cacheNodes })
}));
} else {
console.log('Not using memcached store.');
app.use(session({
resave: false,
saveUninitialized: false, secret: 'your secret here'
}));
}
app.get('/', function (req, resp) {
if (req.session.views) {
req.session.views++
resp.setHeader('Content-Type', 'text/html')
resp.send(`You are session: ${req.session.id}. Views: ${req.session.views}`)
} else {
req.session.views = 1
resp.send(`You are session: ${req.session.id}. No views yet, refresh the page!`)
}
});
if (!module.parent) {
console.log('Running express without cluster. Listening on port %d', process.env.PORT || 5000)
app.listen(process.env.PORT || 5000)
}
}
console.log("Reading elastic cache configuration")
// Load elasticache configuration.
fs.readFile(filename, 'UTF8', function (err, data) {
if (err) throw err;
let cacheNodes = []
if (data) {
let lines = data.split('\n');
for (let i = 0; i < lines.length; i++) {
if (lines[i].length > 0) {
cacheNodes.push(lines[i])
}
}
}
setup(cacheNodes)
});
module.exports = app;
```
1. Remplacez le contenu du fichier `nodejs-example-express-elasticache/bin/www` par ce qui suit :
```
#!/usr/bin/env node
/**
* Module dependencies.
*/
const app = require('../app');
const cluster = require('cluster');
const debug = require('debug')('nodejs-example-express-elasticache:server');
const http = require('http');
const workers = {},
count = require('os').cpus().length;
function spawn() {
const worker = cluster.fork();
workers[worker.pid] = worker;
return worker;
}
/**
* Get port from environment and store in Express.
*/
const port = normalizePort(process.env.PORT || '3000');
app.set('port', port);
if (cluster.isMaster) {
for (let i = 0; i < count; i++) {
spawn();
}
// If a worker dies, log it to the console and start another worker.
cluster.on('exit', function (worker, code, signal) {
console.log('Worker ' + worker.process.pid + ' died.');
cluster.fork();
});
// Log when a worker starts listening
cluster.on('listening', function (worker, address) {
console.log('Worker started with PID ' + worker.process.pid + '.');
});
} else {
/**
* Create HTTP server.
*/
let server = http.createServer(app);
/**
* Event listener for HTTP server "error" event.
*/
function onError(error) {
if (error.syscall !== 'listen') {
throw error;
}
const bind = typeof port === 'string'
? 'Pipe ' + port
: 'Port ' + port;
// handle specific listen errors with friendly messages
switch (error.code) {
case 'EACCES':
console.error(bind + ' requires elevated privileges');
process.exit(1);
break;
case 'EADDRINUSE':
console.error(bind + ' is already in use');
process.exit(1);
break;
default:
throw error;
}
}
/**
* Event listener for HTTP server "listening" event.
*/
function onListening() {
const addr = server.address();
const bind = typeof addr === 'string'
? 'pipe ' + addr
: 'port ' + addr.port;
debug('Listening on ' + bind);
}
/**
* Listen on provided port, on all network interfaces.
*/
server.listen(port);
server.on('error', onError);
server.on('listening', onListening);
}
/**
* Normalize a port into a number, string, or false.
*/
function normalizePort(val) {
const port = parseInt(val, 10);
if (isNaN(port)) {
// named pipe
return val;
}
if (port >= 0) {
// port number
return port;
}
return false;
}
```
1. Déployez les modifications dans votre environnement Elastic Beanstalk avec la commande [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-elasticache$ eb deploy
```
1. Votre environnement est mis à jour au bout de quelques minutes. Une fois que votre environnement est prêt (il apparaît en vert), actualisez l'URL pour vérifier si l'opération a fonctionné. Vous devriez voir une page web indiquant « Welcome to Express ».
Vous pouvez accéder aux journaux des EC2 instances qui exécutent votre application. Pour plus d'informations sur l'accès à vos journaux, consultez [Affichage des journaux des instances Amazon EC2 dans votre environnement Elastic Beanstalk](using-features.logging.md).
Ensuite, mettons à jour l'application Express pour utiliser Amazon ElastiCache.
**Pour mettre à jour votre application Express afin d'utiliser Amazon ElastiCache**
1. Sur votre ordinateur local, créez un répertoire `.ebextensions` dans le répertoire de niveau supérieur de votre groupe source. Dans cet exemple, nous utilisons `nodejs-example-express-elasticache/.ebextensions`.
1. Créez un fichier de configuration `nodejs-example-express-elasticache/.ebextensions/elasticache-iam-with-script.config` avec l'extrait suivant. Pour plus d'informations sur le fichier de configuration, consultez [Espaces de noms de la configuration Node.js](create_deploy_nodejs.container.md#nodejs-namespaces). Il en résulte la création d'un utilisateur IAM avec les autorisations requises pour découvrir les nœuds ElastiCache et l'écriture dans un fichier chaque fois que le cache change. Vous pouvez également copier le fichier depuis un fichier [nodejs-example-express-elasticache.zip.](samples/nodejs-example-express-elasticache.zip) Pour plus d'informations sur les ElastiCache propriétés, consultez[Exemple : ElastiCache](customize-environment-resources-elasticache.md).
**Note**
YAML utilise une mise en retrait cohérente. Respectez le niveau de retrait lorsque vous remplacez du contenu dans un exemple de fichier de configuration et veillez à ce que votre éditeur de texte utilise des espaces, et non des caractères de tabulation, pour la mise en retrait.
```
Resources:
MyCacheSecurityGroup:
Type: 'AWS::EC2::SecurityGroup'
Properties:
GroupDescription: "Lock cache down to webserver access only"
SecurityGroupIngress:
- IpProtocol: tcp
FromPort:
Fn::GetOptionSetting:
OptionName: CachePort
DefaultValue: 11211
ToPort:
Fn::GetOptionSetting:
OptionName: CachePort
DefaultValue: 11211
SourceSecurityGroupName:
Ref: AWSEBSecurityGroup
MyElastiCache:
Type: 'AWS::ElastiCache::CacheCluster'
Properties:
CacheNodeType:
Fn::GetOptionSetting:
OptionName: CacheNodeType
DefaultValue: cache.t2.micro
NumCacheNodes:
Fn::GetOptionSetting:
OptionName: NumCacheNodes
DefaultValue: 1
Engine:
Fn::GetOptionSetting:
OptionName: Engine
DefaultValue: redis
VpcSecurityGroupIds:
-
Fn::GetAtt:
- MyCacheSecurityGroup
- GroupId
AWSEBAutoScalingGroup :
Metadata :
ElastiCacheConfig :
CacheName :
Ref : MyElastiCache
CacheSize :
Fn::GetOptionSetting:
OptionName : NumCacheNodes
DefaultValue: 1
WebServerUser :
Type : AWS::IAM::User
Properties :
Path : "/"
Policies:
-
PolicyName: root
PolicyDocument :
Statement :
-
Effect : Allow
Action :
- cloudformation:DescribeStackResource
- cloudformation:ListStackResources
- elasticache:DescribeCacheClusters
Resource : "*"
WebServerKeys :
Type : AWS::IAM::AccessKey
Properties :
UserName :
Ref: WebServerUser
Outputs:
WebsiteURL:
Description: sample output only here to show inline string function parsing
Value: |
http://`{ "Fn::GetAtt" : [ "AWSEBLoadBalancer", "DNSName" ] }`
MyElastiCacheName:
Description: Name of the elasticache
Value:
Ref : MyElastiCache
NumCacheNodes:
Description: Number of cache nodes in MyElastiCache
Value:
Fn::GetOptionSetting:
OptionName : NumCacheNodes
DefaultValue: 1
files:
"/etc/cfn/cfn-credentials" :
content : |
AWSAccessKeyId=`{ "Ref" : "WebServerKeys" }`
AWSSecretKey=`{ "Fn::GetAtt" : ["WebServerKeys", "SecretAccessKey"] }`
mode : "000400"
owner : root
group : root
"/etc/cfn/get-cache-nodes" :
content : |
# Define environment variables for command line tools
export AWS_ELASTICACHE_HOME="/home/ec2-user/elasticache/$(ls /home/ec2-user/elasticache/)"
export AWS_CLOUDFORMATION_HOME=/opt/aws/apitools/cfn
export PATH=$AWS_CLOUDFORMATION_HOME/bin:$AWS_ELASTICACHE_HOME/bin:$PATH
export AWS_CREDENTIAL_FILE=/etc/cfn/cfn-credentials
export JAVA_HOME=/usr/lib/jvm/jre
# Grab the Cache node names and configure the PHP page
aws cloudformation list-stack-resources --stack `{ "Ref" : "AWS::StackName" }` --region `{ "Ref" : "AWS::Region" }` --output text | grep MyElastiCache | awk '{print $4}' | xargs -I {} aws elasticache describe-cache-clusters --cache-cluster-id {} --region `{ "Ref" : "AWS::Region" }` --show-cache-node-info --output text | grep '^ENDPOINT' | awk '{print $2 ":" $3}' > `{ "Fn::GetOptionSetting" : { "OptionName" : "NodeListPath", "DefaultValue" : "/var/www/html/nodelist" } }`
mode : "000500"
owner : root
group : root
"/etc/cfn/hooks.d/cfn-cache-change.conf" :
"content": |
[cfn-cache-size-change]
triggers=post.update
path=Resources.AWSEBAutoScalingGroup.Metadata.ElastiCacheConfig
action=/etc/cfn/get-cache-nodes
runas=root
sources :
"/home/ec2-user/elasticache" : "https://elasticache-downloads.s3.amazonaws.com/AmazonElastiCacheCli-latest.zip"
commands:
make-elasticache-executable:
command: chmod -R ugo+x /home/ec2-user/elasticache/*/bin/*
packages :
"yum" :
"aws-apitools-cfn" : []
container_commands:
initial_cache_nodes:
command: /etc/cfn/get-cache-nodes
```
1. Sur votre ordinateur local, créez un fichier de configuration `nodejs-example-express-elasticache/.ebextensions/elasticache_settings.config` avec l'extrait de code suivant à configurer. ElastiCache
```
option_settings:
"aws:elasticbeanstalk:customoption":
CacheNodeType: cache.t2.micro
NumCacheNodes: 1
Engine: memcached
NodeListPath: /var/nodelist
```
1. Sur votre ordinateur local, remplacez `nodejs-example-express-elasticache/express-app.js` par l'extrait suivant. Ce fichier lit la liste des nœuds depuis le disque (`/var/nodelist`) et configure Express de façon à utiliser `memcached` comme magasin de sessions s'il existe des nœuds. Votre fichier doit se présenter comme suit :
```
/**
* Module dependencies.
*/
var express = require('express'),
session = require('express-session'),
bodyParser = require('body-parser'),
methodOverride = require('method-override'),
cookieParser = require('cookie-parser'),
fs = require('fs'),
filename = '/var/nodelist',
app = module.exports = express();
var MemcachedStore = require('connect-memcached')(session);
function setup(cacheNodes) {
app.use(bodyParser.raw());
app.use(methodOverride());
if (cacheNodes) {
app.use(cookieParser());
console.log('Using memcached store nodes:');
console.log(cacheNodes);
app.use(session({
secret: 'your secret here',
resave: false,
saveUninitialized: false,
store: new MemcachedStore({'hosts': cacheNodes})
}));
} else {
console.log('Not using memcached store.');
app.use(cookieParser('your secret here'));
app.use(session());
}
app.get('/', function(req, resp){
if (req.session.views) {
req.session.views++
resp.setHeader('Content-Type', 'text/html')
resp.write('Views: ' + req.session.views)
resp.end()
} else {
req.session.views = 1
resp.end('Refresh the page!')
}
});
if (!module.parent) {
console.log('Running express without cluster.');
app.listen(process.env.PORT || 5000);
}
}
// Load elasticache configuration.
fs.readFile(filename, 'UTF8', function(err, data) {
if (err) throw err;
var cacheNodes = [];
if (data) {
var lines = data.split('\n');
for (var i = 0 ; i < lines.length ; i++) {
if (lines[i].length > 0) {
cacheNodes.push(lines[i]);
}
}
}
setup(cacheNodes);
});
```
1. Sur votre ordinateur local, mettez à jour `package.json` avec le contenu suivant :
```
"dependencies": {
"cookie-parser": "~1.4.4",
"debug": "~2.6.9",
"express": "~4.16.1",
"http-errors": "~1.6.3",
"jade": "~1.11.0",
"morgan": "~1.9.1",
"connect-memcached": "*",
"express-session": "*",
"body-parser": "*",
"method-override": "*"
}
```
1. Exécutez **npm install**.
```
~/nodejs-example-express-elasticache$ npm install
```
1. Déployez l'application mise à jour.
```
~/nodejs-example-express-elasticache$ eb deploy
```
1. Votre environnement est mis à jour au bout de quelques minutes. Une fois que votre environnement est prêt (il apparaît en vert), assurez-vous que le code a fonctionné.
1. Consultez la [ CloudWatch console Amazon](https://console.aws.amazon.com/cloudwatch/home) pour consulter vos ElastiCache statistiques. Pour afficher vos ElastiCache statistiques, sélectionnez **Métriques** dans le volet de gauche, puis recherchez **CurrItems**. Sélectionnez **ElastiCache > Mesures du nœud de cache**, puis sélectionnez votre nœud de cache pour afficher le nombre d'éléments contenus dans le cache.
![\[CloudWatch dashboard showing CurrItems metric for an ElastiCache node over time.\]](http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/images/elasticache-express.png)
**Note**
Vérifiez que vous consultez bien la même région que celle dans laquelle vous avez déployé votre application.
Si vous copiez et collez l'URL de votre application dans un autre navigateur Web et que vous actualisez la page, vous devriez voir votre CurrItem compte augmenter au bout de 5 minutes.
1. Prenez un instantané de vos journaux. Pour de plus amples informations sur la récupération des journaux, veuillez consulter [Affichage des journaux des instances Amazon EC2 dans votre environnement Elastic Beanstalk](using-features.logging.md).
1. Vérifiez le fichier `/var/log/nodejs/nodejs.log` dans le groupe des journaux. Le résultat devrait être similaire à ce qui suit :
```
Using memcached store nodes:
[ 'aws-my-1oys9co8zt1uo.1iwtrn.0001.use1.cache.amazonaws.com:11211' ]
```
## Nettoyage
Si vous ne souhaitez plus exécuter votre application, vous pouvez effectuer un nettoyage en suspendant votre environnement et en supprimant votre application.
Utilisez la commande `eb terminate` pour mettre votre environnement hors service et la commande `eb delete` pour supprimer votre application.
**Pour résilier votre environnement**
Depuis le répertoire où vous avez créé votre référentiel local, exécutez `eb terminate`.
```
$ eb terminate
```
Ce processus peut prendre quelques minutes. Elastic Beanstalk affiche un message une fois que l'environnement est arrêté.
# Déploiement d'une application Node.js avec DynamoDB vers Elastic Beanstalk
Ce didacticiel et son exemple d'application [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) vous guident JavaScript dans le processus de déploiement d'une application Node.js qui utilise le AWS SDK de Node.js pour interagir avec le service Amazon DynamoDB. Vous allez créer une table DynamoDB qui se trouve dans une base de données découplée, ou externe, de l'environnement. AWS Elastic Beanstalk Vous allez également configurer l'application pour qu'elle utilise une base de données dissociée. Dans un environnement de production, l'utilisation d'une base de données dissociée de l'environnement Elastic Beanstalk constitue une bonne pratique, afin qu'elle soit indépendante du cycle de vie de l'environnement. Cette pratique vous permet également d'effectuer des [déploiements bleus/verts](using-features.CNAMESwap.md).
L'exemple d'application illustre ce qui suit :
+ Une table DynamoDB qui stocke des données textuelles fournies par l'utilisateur.
+ Les [fichiers de configuration](ebextensions.md) pour créer la table.
+ Une rubrique Amazon Simple Notification Service.
+ L'utilisation d'un [fichier package.json](nodejs-platform-dependencies.md#nodejs-platform-packagejson) pour installer des packages pendant le déploiement.
**Topics**
+ [Conditions préalables](#nodejs-dynamodb-tutorial-prereqs)
+ [Créer un environnement Elastic Beanstalk](#nodejs-dynamodb-tutorial-launch)
+ [Ajout d'autorisations aux instances de votre environnement](#nodejs-dynamodb-tutorial-role)
+ [Déploiement de l'exemple d'application](#nodejs-dynamodb-tutorial-deploy)
+ [Créez une table DynamoDB](#nodejs-dynamodb-tutorial-database)
+ [Mise à jour des fichiers de configuration de l'application](#nodejs-dynamodb-tutorial-update)
+ [Configuration de votre environnement pour une haute disponibilité](#nodejs-dynamodb-tutorial-configure)
+ [Nettoyage](#nodejs-dynamodb-tutorial-cleanup)
+ [Étapes suivantes](#nodejs-dynamodb-tutorial-nextsteps)
## Conditions préalables
Ce tutoriel nécessite les prérequis suivants :
+ Les exécutions Node.js
+ Le logiciel de gestion des packages Node.js par défaut, npm
+ Le générateur de ligne de commande Express
+ Interface de ligne de commande Elastic Beanstalk (EB)
Pour plus d'informations sur l'installation des trois premiers composants et la configuration de votre environnement de développement local, consultez [Configuration de votre environnement de développement Node.js pour Elastic Beanstalk](nodejs-devenv.md). Pour ce didacticiel, il n'est pas nécessaire d'installer le AWS SDK pour Node.js, qui est également mentionné dans la rubrique référencée.
Pour plus d'informations sur l'installation et la configuration de l'EB CLI, consultez [Installation de la CLI EB avec un script de configuration (recommandé)](eb-cli3.md#eb-cli3-install) et [Configuration de l'interface de ligne de commande EB](eb-cli3-configuration.md).
## Créer un environnement Elastic Beanstalk
**Votre répertoire d'application**
Ce tutoriel utilise un répertoire appelé `nodejs-example-dynamo` pour la création de la solution groupée de l'application. Créez le répertoire `nodejs-example-dynamo` pour ce tutoriel.
```
~$ mkdir nodejs-example-dynamo
```
**Note**
Chaque tutoriel de ce chapitre utilise son propre répertoire pour la solution groupée de l'application. Le nom du répertoire correspond au nom de l'exemple d'application utilisé par le tutoriel.
Changez votre répertoire de travail actuel vers `nodejs-example-dynamo`.
```
~$ cd nodejs-example-dynamo
```
Configurons maintenant un environnement Elastic Beanstalk exécutant la plateforme Node.js et l'exemple d'application. Nous utiliserons l'interface de ligne de commande Elastic Beanstalk (EB CLI).
**Pour configurer un référentiel de l'EB CLI pour votre application et créer un environnement Elastic Beanstalk qui exécute la plateforme Node.js**
1. Créez un référentiel à l'aide de la commande **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-dynamo$ eb init --platform node.js --region
```
Cette commande crée un fichier de configuration dans un dossier nommé `.elasticbeanstalk` qui spécifie les paramètres de création d'environnements pour votre application et crée une application Elastic Beanstalk dont le nom est basé sur le dossier actif.
1. Créez un environnement qui exécute un exemple d'application à l'aide de la commande **[**eb create**](eb3-create.md)**.
```
~/nodejs-example-dynamo$ eb create --sample nodejs-example-dynamo
```
Cette commande crée un environnement à charge équilibrée avec les paramètres par défaut de la plateforme Node.js et les ressources suivantes :
+ **EC2 instance** — Une machine virtuelle Amazon Elastic Compute Cloud (Amazon EC2) configurée pour exécuter des applications Web sur la plateforme de votre choix.
Chaque plateforme exécute un ensemble spécifique de logiciels, de fichiers de configuration et de scripts pour prendre en charge une version de langage, une infrastructure ou un conteneur web spécifiques, ou une combinaison de ces éléments. La plupart des plateformes utilisent Apache ou nginx comme proxy inverse situé devant votre application web, qui lui transmet des demandes, traite des ressources statiques et génère des journaux d'accès et d'erreur.
+ **Groupe de sécurité d'instance** : groupe EC2 de sécurité Amazon configuré pour autoriser le trafic entrant sur le port 80. Cette ressource permet au trafic HTTP provenant de l'équilibreur de charge d'atteindre l' EC2 instance qui exécute votre application Web. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **Équilibreur de charge** – Équilibreur de charge Elastic Load Balancing configuré pour répartir les demandes vers les instances exécutant votre application. De plus, l'équilibreur de charge vous évite d'exposer directement vos instances sur Internet.
+ Groupe de **sécurité d'équilibrage de charge : groupe** EC2 de sécurité Amazon configuré pour autoriser le trafic entrant sur le port 80. Cette ressource autorise le trafic HTTP provenant d'Internet à atteindre l'équilibreur de charge. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **Groupe Auto Scaling** – Groupe Auto Scaling configuré pour remplacer une instance si elle est résiliée ou devient indisponible.
+ **Compartiment Amazon S3** – Emplacement de stockage pour votre code source, les journaux et autres artefacts qui sont créés lorsque vous utilisez Elastic Beanstalk.
+ ** CloudWatch Alarmes Amazon** : deux CloudWatch alarmes qui surveillent la charge sur les instances de votre environnement et qui sont déclenchées si la charge est trop élevée ou trop faible. Lorsqu'une alarme est déclenchée, votre groupe Auto Scaling s'adapte en fonction, à la hausse ou à la baisse.
+ **CloudFormation stack** — Elastic CloudFormation Beanstalk utilise pour lancer les ressources de votre environnement et propager les modifications de configuration. Les ressources sont définies dans un modèle, que vous pouvez afficher dans la [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nom de domaine** : nom de domaine qui permet d'accéder à votre application Web dans le formulaire **subdomain*. *region*.elasticbeanstalk.com*.
**Sécurité du domaine**
Pour renforcer la sécurité de vos applications Elastic Beanstalk, le domaine *elasticbeanstalk.com* est enregistré dans la [liste des suffixes publics (PSL)](https://publicsuffix.org/).
Si vous devez définir des cookies sensibles dans le nom de domaine par défaut de vos applications Elastic Beanstalk, nous vous recommandons d'utiliser des cookies `__Host-` avec un préfixe pour une sécurité accrue. Cette pratique protège votre domaine contre les tentatives de falsification de requêtes intersites (CSRF). Pour plus d'informations, consultez la page [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) du Mozilla Developer Network.
1. Une fois l'environnement créé, utilisez la commande [**eb open**](eb3-open.md) pour ouvrir l'URL de l'environnement dans le navigateur par défaut.
```
~/nodejs-example-dynamo$ eb open
```
Vous avez maintenant créé un environnement Node.js Elastic Beanstalk avec un exemple d'application. Vous pouvez le mettre à jour avec votre propre application. Ensuite, nous mettons à jour l'exemple d'application afin d'utiliser l'infrastructure Express.
## Ajout d'autorisations aux instances de votre environnement
Votre application s'exécute sur une ou plusieurs EC2 instances derrière un équilibreur de charge, servant les requêtes HTTP provenant d'Internet. Lorsqu'elle reçoit une demande qui l'oblige à utiliser AWS des services, l'application utilise les autorisations de l'instance sur laquelle elle s'exécute pour accéder à ces services.
L'exemple d'application utilise les autorisations d'instance pour écrire des données dans une table DynamoDB et pour envoyer des notifications à une rubrique Amazon SNS à l'aide du SDK pour Node.js. JavaScript Ajoutez les politiques gérées suivantes au [profil d'instance](concepts-roles-instance.md) par défaut pour autoriser les EC2 instances de votre environnement à accéder à DynamoDB et à Amazon SNS :
+ **AmazonDynamoDBFullAccès**
+ **Amazon SNSFull Access**
**Pour ajouter des stratégies au profil d'instance par défaut**
1. Ouvrez la page [Roles (Rôles)](https://console.aws.amazon.com/iam/home#roles) dans la console IAM.
1. Choisissez **aws-elasticbeanstalk-ec2 rôles**.
1. Sous l'onglet **Permissions** (Autorisations), choisissez **Attach policies** (Attacher des politiques).
1. Sélectionnez la politique gérée relative aux services supplémentaires utilisés par votre application. Dans le cadre de ce tutoriel, sélectionnez `AmazonSNSFullAccess` et `AmazonDynamoDBFullAccess`.
1. Choisissez **Attach policy** (Attacher la politique).
Pour de plus amples informations sur la gestion des profils d'instance, veuillez consulter [Gestion des profils d'instance Elastic Beanstalk](iam-instanceprofile.md).
## Déploiement de l'exemple d'application
Votre environnement est maintenant prêt pour que vous puissiez déployer et exécuter l'exemple d'application pour ce didacticiel : [nodejs-example-dynamo.zip.](samples/nodejs-example-dynamo.zip)
**Pour déployer et exécuter l'exemple d'application du tutoriel**
1. Changez votre répertoire de travail actuel vers le répertoire de l'application `nodejs-example-dynamo`.
```
~$ cd nodejs-example-dynamo
```
1. Téléchargez et extrayez le contenu de l'exemple de bundle source d'application [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) dans le répertoire `nodejs-example-dynamo` de l'application.
1. Déployez l'exemple d'application dans votre environnement Elastic Beanstalk avec la commande [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-dynamo$ eb deploy
```
**Note**
Par défaut, la `eb deploy` commande crée un fichier ZIP du dossier de votre projet. Vous pouvez configurer l'interface de ligne de commande (CLI) EB pour déployer un artefact de votre processus de construction au lieu de créer un fichier ZIP de votre dossier de projet. Pour de plus amples informations, veuillez consulter [Déploiement d'un artefact à la place du dossier de projet](eb-cli3-configuration.md#eb-cli3-artifact).
1. Une fois l'environnement créé, utilisez la commande [**eb open**](eb3-open.md) pour ouvrir l'URL de l'environnement dans le navigateur par défaut.
```
~/nodejs-example-dynamo$ eb open
```
Le site collecte les informations de contact des utilisateurs et stocke les données dans une table DynamoDB. Pour ajouter une entrée, choisissez **Sign up today (Inscrivez-vous aujourd'hui)**, entrez un nom et une adresse e-mail et choisissez **Sign Up\$1 (Inscrivez-vous)**. L'application web écrit le contenu du formulaire dans la table et déclenche une notification Amazon SNS par e-mail.
![\[Startup landing page with teaser message and sign-up button for upcoming product launch.\]](http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/images/nodejs-dynamodb-tutorial-app.png)
Pour le moment, la rubrique Amazon SNS est configurée avec un e-mail à espace réservé pour les notifications. Vous allez mettre à jour la configuration prochainement, mais en attendant, vous pouvez vérifier la table DynamoDB et la rubrique Amazon SNS dans AWS Management Console Management Console.
**Pour afficher la table**
1. Ouvrez la [page Tables](https://console.aws.amazon.com/dynamodb/home?#tables:) dans la console DynamoDB.
1. Recherchez la table créée par l'application. Le nom commence par **awseb et contient**. **StartupSignupsTable**
1. Sélectionnez la table, choisissez **Items** (Éléments), puis **Start search** (Commencer la recherche) afin d'afficher tous les éléments de la table.
La table contient une entrée pour chaque adresse e-mail fournie sur le site d'inscription. En plus d'écrire les données dans la table, l'application envoie un message à une rubrique Amazon SNS qui compte deux abonnements. Le premier abonnement est pour les notifications par e-mail qui vous sont adressées et l'autre pour une file d'attente Amazon Simple Queue Service qu'une application de travail peut lire afin de traiter les demandes et d'envoyer des e-mails aux clients intéressés.
**Pour afficher la rubrique**
1. Ouvrez la [page Topics (Rubriques)](https://console.aws.amazon.com/sns/v2/home?#/topics) dans la console Amazon SNS.
1. Recherchez la rubrique créée par l'application. Le nom commence par **awseb et contient**. **NewSignupTopic**
1. Choisissez la rubrique pour afficher ses abonnements.
L'application (`[app.js](https://github.com/awslabs/eb-node-express-sample/blob/master/app.js)`) définit deux routes. Le chemin racine (`/`) renvoie une page Web rendue à partir d'un modèle intégré JavaScript (EJS) avec un formulaire que l'utilisateur remplit pour enregistrer son nom et son adresse e-mail. La soumission du formulaire envoie une demande POST avec les données du formulaire vers l'acheminement `/signup`, qui écrit une entrée dans la table DynamoDB et publie un message dans la rubrique Amazon SNS pour informer le propriétaire de l'inscription.
L'exemple d'application inclut des [fichiers de configuration](ebextensions.md) qui créent la table DynamoDB, la rubrique Amazon SNS et la file d'attente Amazon SQS utilisées par l'application. Cela vous permet de créer un nouvel environnement et de tester la fonctionnalité immédiatement, mais en revanche la table DynamoDB est liée à l'environnement. Pour un environnement de production, vous devez créer la table DynamoDB en dehors de l'environnement afin d'éviter de la perdre lorsque vous arrêtez l'environnement ou que vous mettez sa configuration à jour.
## Créez une table DynamoDB
Pour utiliser une table DynamoDB externe avec une application exécutée dans Elastic Beanstalk, créez d'abord une table dans DynamoDB. Lorsque vous créez une table en dehors d'Elastic Beanstalk, elle est complètement indépendante d'Elastic Beanstalk et de vos environnements Elastic Beanstalk et ne sera pas arrêtée par Elastic Beanstalk.
Créez une table avec les paramètres suivants :
+ **Nom de la table** – **nodejs-tutorial**
+ **Clé primaire** – **email**
+ Type de clé primaire – **Chaîne**
**Pour créer une table DynamoDB**
1. Ouvrez la [page Tables](https://console.aws.amazon.com/dynamodb/home?#tables:) dans la console de gestion DynamoDB.
1. Choisissez **Créer un tableau**.
1. Entrez un **nom de table** et une **clé primaire**.
1. Choisissez le type de clé primaire.
1. Choisissez **Créer**.
## Mise à jour des fichiers de configuration de l'application
Mettez à jour les [fichiers de configuration](ebextensions.md) dans la source de l'application afin d'utiliser la table **nodejs-tutorial** au lieu d'en créer une nouvelle.
**Pour mettre à jour l'exemple d'application pour l'utilisation en production**
1. Changez votre répertoire de travail actuel vers le répertoire de l'application `nodejs-example-dynamo`.
```
~$ cd nodejs-example-dynamo
```
1. Ouvrez `.ebextensions/options.config` et modifiez les valeurs des paramètres suivants :
+ **NewSignupEmail**— Votre adresse e-mail.
+ **STARTUP\$1SIGNUP\$1TABLE** – **nodejs-tutorial**
**Example .ebextensions/options.config**
```
option_settings:
aws:elasticbeanstalk:customoption:
NewSignupEmail: you@example.com
aws:elasticbeanstalk:application:environment:
THEME: "flatly"
AWS_REGION: '`{"Ref" : "AWS::Region"}`'
STARTUP_SIGNUP_TABLE: nodejs-tutorial
NEW_SIGNUP_TOPIC: '`{"Ref" : "NewSignupTopic"}`'
aws:elasticbeanstalk:container:nodejs:
ProxyServer: nginx
aws:elasticbeanstalk:container:nodejs:staticfiles:
/static: /static
aws:autoscaling:asg:
Cooldown: "120"
aws:autoscaling:trigger:
Unit: "Percent"
Period: "1"
BreachDuration: "2"
UpperThreshold: "75"
LowerThreshold: "30"
MeasureName: "CPUUtilization"
```
Les configurations suivantes sont appliquées à l'application :
+ L'adresse e-mail que la rubrique Amazon SNS utilise pour les notifications est définie sur votre adresse, ou celle que vous saisissez dans le fichier `options.config`.
+ La table **nodejs-tutorial** sera utilisée à la place de celle créée par `.ebextensions/create-dynamodb-table.config`.
1. Supprimez `.ebextensions/create-dynamodb-table.config`.
```
~/nodejs-tutorial$ rm .ebextensions/create-dynamodb-table.config
```
La prochaine fois que vous déployez l'application, la table créée par ce fichier de configuration sera supprimée.
1. Déployez l'application mise à jour dans votre environnement Elastic Beanstalk avec la commande [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-dynamo$ eb deploy
```
1. Une fois l'environnement créé, utilisez la commande [**eb open**](eb3-open.md) pour ouvrir l'URL de l'environnement dans le navigateur par défaut.
```
~/nodejs-example-dynamo$ eb open
```
Lors du déploiement, Elastic Beanstalk met à jour la configuration de la rubrique Amazon SNS et supprime la table DynamoDB créée lorsque vous avez déployé la première version de l'application.
Désormais, lorsque vous résiliez l'environnement, la table **nodejs-tutorial** n'est pas supprimée. Cela vous permet d'effectuer des déploiements bleu/vert, de modifier les fichiers de configuration ou d'arrêter votre site web sans risque de perte de données.
Ouvrez votre site dans un navigateur et vérifiez que le formulaire fonctionne comme prévu. Créez quelques entrées et vérifiez la table dans la console DynamoDB.
**Pour afficher la table**
1. Ouvrez la [page Tables](https://console.aws.amazon.com/dynamodb/home?#tables:) dans la console DynamoDB.
1. Recherchez la table **nodejs-tutorial**.
1. Sélectionnez la table, choisissez **Items** (Éléments), puis **Start search** (Commencer la recherche) afin d'afficher tous les éléments de la table.
Vous pouvez également voir qu'Elastic Beanstalk a supprimé la table créée précédemment.
## Configuration de votre environnement pour une haute disponibilité
Enfin, configurez le groupe Auto Scaling de votre environnement avec un nombre minimum d'instances plus élevé. Exécutez au moins deux instances en permanence afin d'empêcher que les serveurs web de votre environnement constituent un point de défaillance unique et pour vous permettre de déployer des modifications sans mettre votre site hors service.
**Pour configurer le groupe Auto Scaling de votre environnement pour une haute disponibilité**
1. Ouvrez la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk), puis **dans la liste des régions, sélectionnez votre**. Région AWS
1. Dans le panneau de navigation, choisissez **Environments** (Environnements), puis choisissez le nom de votre environnement dans la liste.
1. Dans le panneau de navigation, choisissez **Configuration**.
1. Dans la catégorie de configuration **Capacity** (Capacité), choisissez **Edit** (Modifier).
1. Dans la section **Auto Scaling group** (Groupe Auto Scaling), définissez les **Min instances** (Instances min.) sur **2**.
1. Pour enregistrer les modifications, cliquez sur **Appliquer** en bas de la page.
## Nettoyage
Une fois que vous avez fini d'utiliser le code de démonstration, vous pouvez mettre fin à votre environnement. [Elastic Beanstalk supprime toutes les ressources AWS associées, [telles que les instances EC2 Amazon](using-features.managing.ec2.md)[, les instances de base de données, les équilibreurs de charge, les](using-features.managing.db.md)[groupes de sécurité](using-features.managing.elb.md) et les alarmes.](using-features.alarms.md#using-features.alarms.title)
La suppression de ressources n'entraîne pas la suppression de l'application Elastic Beanstalk. Vous pouvez donc créer de nouveaux environnements pour votre application à tout moment.
**Pour mettre fin à votre environnement Elastic Beanstalk depuis la console**
1. Ouvrez la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk), puis **dans la liste des régions, sélectionnez votre**. Région AWS
1. Dans le panneau de navigation, choisissez **Environments** (Environnements), puis choisissez le nom de votre environnement dans la liste.
1. Choisissez **Actions** (Actions), puis **Terminate Environment** (Résilier l’environnement).
1. Utilisez la boîte de dialogue à l'écran pour confirmer la résiliation de l'environnement.
Vous pouvez également supprimer les tables DynamoDB externes que vous avez créées.
**Pour supprimer une table DynamoDB**
1. Ouvrez la [page Tables](https://console.aws.amazon.com/dynamodb/home?#tables:) dans la console DynamoDB.
1. Sélectionnez une table.
1. Choisissez **Actions**, puis **Delete table (Supprimer la table)**.
1. Choisissez **Supprimer**.
## Étapes suivantes
L'exemple d'application utilise des fichiers de configuration pour configurer les paramètres logiciels et créer AWS des ressources dans le cadre de votre environnement. Pour de plus amples informations sur les fichiers de configuration et leur utilisation, veuillez consulter [Personnalisation d'environnement avancée avec fichiers de configuration (`.ebextensions`)](ebextensions.md).
L'exemple d'application de ce tutoriel utilise l'infrastructure web Express pour Node.js. Pour plus d'informations sur Express, consultez la documentation officielle à l'adresse [expressjs.com](https://expressjs.com).
Enfin, si vous prévoyez d'utiliser votre application dans un environnement de production, [configurez un nom de domaine personnalisé](customdomains.md) pour votre environnement et [activez HTTPS](configuring-https.md) pour des connexions sécurisées.
# Ajout d'une instance de base de données Amazon RDS à votre environnement Node.js Elastic Beanstalk
Cette rubrique fournit des instructions pour créer un Amazon RDS à l'aide de la console Elastic Beanstalk. Vous pouvez utiliser une instance de base de données Amazon Relational Database Service (Amazon RDS) pour stocker les données collectées et modifiées par votre application. La base de données peut être liée à votre environnement et gérée par Elastic Beanstalk, ou elle peut être créée comme déliée et gérée en externe par un autre service. Dans ces instructions, la base de données est couplée à votre environnement et gérée par Elastic Beanstalk. Pour plus d'informations sur l'intégration d'un Amazon RDS avec Elastic Beanstalk, consultez [Ajout d'une base de données à votre environnement Elastic Beanstalk](using-features.managing.db.md).
**Topics**
+ [Ajout d'une instance de base de données à votre environnement](#nodejs-rds-create)
+ [Téléchargement d'un pilote](#nodejs-rds-drivers)
+ [Connexion à une base de données](#nodejs-rds-connect)
## Ajout d'une instance de base de données à votre environnement
**Pour ajouter une instance DB à votre environnement**
1. Ouvrez la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk), puis **dans la liste des régions, sélectionnez votre**. Région AWS
1. Dans le panneau de navigation, choisissez **Environments** (Environnements), puis choisissez le nom de votre environnement dans la liste.
1. Dans le panneau de navigation, choisissez **Configuration**.
1. Dans la catégorie de configuration **Database (Base de données)**, choisissez **Edit (Modifier)**.
1. Choisissez un moteur de base de données, puis saisissez un nom d'utilisateur et un mot de passe.
1. Pour enregistrer les modifications, cliquez sur **Appliquer** en bas de la page.
L'ajout d'une instance DB prend environ 10 minutes. Une fois la mise à jour de l'environnement terminée, le nom d'hôte de l'instance DB et les autres informations de connexion sont disponibles dans votre application, via les propriétés d'environnement suivantes :
| Nom de la propriété | Description | Valeur de la propriété |
| --- | --- | --- |
| `RDS_HOSTNAME` | Nom d'hôte de l'instance DB. | Sous l'onglet **Connectivity & security** (Connectivité et sécurité) de la console Amazon RDS : **Endpoint** (Point de terminaison). |
| `RDS_PORT` | Port sur lequel l'instance de base de données accepte des connexions. La valeur par défaut varie selon les moteurs de base de données. | Sous l'onglet **Connectivity & security (Connectivité et sécurité)** de la console Amazon RDS : **Port**. |
| `RDS_DB_NAME` | Nom de la base de données, **ebdb**. | Sous l'onglet **Configuration** de la console Amazon RDS : **DB Name (Nom de base de données)**. |
| `RDS_USERNAME` | Nom d'utilisateur que vous avez configuré pour votre base de données. | Sous l'onglet **Configuration** de la console Amazon RDS : **Master username (Identifiant principal)**. |
| `RDS_PASSWORD` | Mot de passe que vous avez configuré pour votre base de données. | Non disponible pour référence dans la console Amazon RDS. |
Pour plus d'informations sur la configuration d'une instance de base de données liée à un environnement Elastic Beanstalk, consultez [Ajout d'une base de données à votre environnement Elastic Beanstalk](using-features.managing.db.md).
## Téléchargement d'un pilote
Ajoutez le pilote de base de données au fichier [`package.json`](nodejs-platform-dependencies.md#nodejs-platform-packagejson) de votre projet sous `dependencies`.
**Example `package.json` – Express avec MySQL**
```
{
"name": "my-app",
"version": "0.0.1",
"private": true,
"dependencies": {
"ejs": "latest",
"aws-sdk": "latest",
"express": "latest",
"body-parser": "latest",
"mysql": "latest"
},
"scripts": {
"start": "node app.js"
}
}
```
**Packages de pilotes courants pour Node.js**
+ **MySQL** – [mysql](https://www.npmjs.com/package/mysql)
+ **PostgreSQL** – [node-postgres](https://www.npmjs.com/package/pg)
+ **SQL Server** – [node-mssql](https://www.npmjs.com/package/mssql)
+ **Oracle** – [node-oracledb](https://www.npmjs.com/package/oracledb)
## Connexion à une base de données
Elastic Beanstalk fournit des informations de connexion pour les instances de base de données attachées dans les propriétés de l'environnement. Utilisez `process.env.VARIABLE` pour lire les propriétés et configurer une connexion de base de données.
**Example app.js – Connexion à une base de données MySQL**
```
var mysql = require('mysql');
var connection = mysql.createConnection({
host : process.env.RDS_HOSTNAME,
user : process.env.RDS_USERNAME,
password : process.env.RDS_PASSWORD,
port : process.env.RDS_PORT
});
connection.connect(function(err) {
if (err) {
console.error('Database connection failed: ' + err.stack);
return;
}
console.log('Connected to database.');
});
connection.end();
```
[Pour plus d'informations sur la construction d'une chaîne de connexion à l'aide de node-mysql, consultez npmjs. org/package/mysql](https://npmjs.org/package/mysql).
# Outils et ressources Node.js
Voici plusieurs ressources vous permettant d'obtenir une aide supplémentaire lors du développement de vos applications Node.js :
****
| Ressource | Description |
| --- | --- |
| [GitHub](https://github.com/aws/aws-sdk-js) | Installez le AWS SDK pour Node.js à l'aide GitHub de. |
| [AWS SDK pour Node.js (version préliminaire pour les développeurs)](https://aws.amazon.com/sdkfornodejs/) | Guichet unique pour l'exemple de code, la documentation, les outils et les ressources supplémentaires. |