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'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é.