Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Distribuzione di un'applicazione Node.js Express con clustering su Elastic Beanstalk
[http://expressjs.com/](http://expressjs.com/) Il clustering migliora l'alta disponibilità, le prestazioni e la sicurezza della tua applicazione Web. Per ulteriori informazioni su Amazon ElastiCache, consulta [What Is Amazon ElastiCache (Memcached](https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/Introduction.html))? nella Guida per l'*utente di Amazon ElastiCache (Memcached)*.
**Nota**
Questo esempio crea AWS risorse che potrebbero esserti addebitate. Per ulteriori informazioni sui AWS prezzi, consulta[https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/). Alcuni servizi fanno parte del piano di utilizzo AWS gratuito. Se sei un nuovo cliente, puoi provare questi servizi gratuitamente. Per ulteriori informazioni, consultare [https://aws.amazon.com/free/](https://aws.amazon.com/free/).
## Prerequisiti
Di seguito sono elencati i requisiti per questo tutorial:
+ I runtime Node.js
+ Il software predefinito per la gestione dei pacchetti Node.js, npm
+ Il generatore di righe di comando Express
+ interfaccia a riga di comando Elastic Beanstalk (CLI EB)
Per ulteriori informazioni sull'installazione dei primi tre componenti riportati e la configurazione dell'ambiente di sviluppo locale, consulta [Configurazione dell'ambiente di sviluppo Node.js per Elastic Beanstalk](nodejs-devenv.md). Per questo tutorial, non è necessario installare l' AWS SDK per Node.js, anch'esso menzionato nell'argomento di riferimento.
Per maggiori dettagli sull'installazione e la configurazione della CLI EB, consulta [Installa EB CLI con lo script di configurazione (consigliato)](eb-cli3.md#eb-cli3-install) e [Configurazione dell'interfaccia a riga di comando EB](eb-cli3-configuration.md).
## Creazione di un ambiente Elastic Beanstalk
**La tua directory delle applicazioni**
Questo tutorial utilizza una directory chiamata `nodejs-example-express-elasticache` per il pacchetto sorgente dell'applicazione. Crea la directory `nodejs-example-express-elasticache` per questo tutorial.
```
~$ mkdir nodejs-example-express-elasticache
```
**Nota**
Ogni tutorial in questo capitolo utilizza la propria directory per il pacchetto sorgente dell'applicazione. Il nome della directory corrisponde al nome dell'applicazione di esempio utilizzata dal tutorial.
Cambia la tua directory di lavoro corrente in `nodejs-example-express-elasticache`.
```
~$ cd nodejs-example-express-elasticache
```
Configura ora un ambiente Elastic Beanstalk in cui viene eseguita la piattaforma Node.js e l'applicazione di esempio. Utilizzeremo l'interfaccia a riga di comando di Elastic Beanstalk (CLI EB).
**Configurazione di un repository della CLI EB per l'applicazione e creaione di un ambiente Elastic Beanstalk in cui viene eseguita la piattaforma Node.js**
1. Creazione di un repository con il comando **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-express-elasticache$ eb init --platform {{node.js}} --region {{}}
```
Questo comando crea un file di configurazione in una cartella denominata `.elasticbeanstalk`, che specifica le impostazioni per la creazione di ambienti per l'applicazione e crea un'applicazione Elastic Beanstalk che prende nome dalla cartella corrente.
1. Crea un ambiente che esegue un'applicazione di esempio con il comando **[**eb create**](eb3-create.md)**.
```
~/nodejs-example-express-elasticache$ eb create --sample {{nodejs-example-express-elasticache}}
```
Questo comando crea un ambiente con bilanciamento del carico con le impostazioni predefinite per la piattaforma Node.js e le risorse seguenti:
+ **Istanza EC2**: una macchina virtuale Amazon Elastic Compute Cloud (Amazon EC2) configurata per l'esecuzione di app Web sulla piattaforma scelta.
Ogni piattaforma esegue un insieme specifico di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di essi. La maggior parte delle piattaforme utilizza Apache o NGINX come proxy inverso su cui viene eseguita l'app Web, inoltra le richieste all'app, fornisce asset statici e genera log degli accessi e di errore.
+ **Gruppo di sicurezza istanze**: un gruppo di sicurezza di Amazon EC2 configurato per abilitare il traffico in entrata sulla porta 80. Questa risorsa consente al traffico TTP proveniente dal sistema di bilanciamento del carico di raggiungere l'istanza EC2 in esecuzione sull'app Web. Per impostazione predefinita, il traffico non è consentito su altre porte.
+ **Sistema di bilanciamento del carico**: un sistema di bilanciamento del carico Elastic Load Balancing configurato per distribuire richieste alle istanze in esecuzione sull'applicazione. Un sistema di bilanciamento del carico inoltre elimina la necessità di esporre le proprie istanze direttamente in Internet.
+ **Gruppo di sicurezza del sistema di bilanciamento del carico**: un gruppo di sicurezza di Amazon EC2 configurato per abilitare il traffico in entrata sulla porta 80. Questa risorsa HTTP consente al traffico proveniente da Internet di raggiungere il sistema di bilanciamento del carico. Per impostazione predefinita, il traffico non è consentito su altre porte.
+ **Gruppo Auto Scaling**: un gruppo Auto Scaling configurato per sostituire un'istanza se viene terminata o diventa non disponibile.
+ **Bucket Amazon S3**: posizione di storage per il codice sorgente, i log e altri artefatti creati quando si utilizza Elastic Beanstalk.
+ ** CloudWatch Allarmi Amazon**: due CloudWatch allarmi che monitorano il carico sulle istanze nel tuo ambiente e che vengono attivati se il carico è troppo alto o troppo basso. Quando viene attivato un allarme, il gruppo Auto Scaling aumenta o diminuisce di conseguenza.
+ **CloudFormation stack**: Elastic CloudFormation Beanstalk utilizza per avviare le risorse nell'ambiente e propagare le modifiche alla configurazione. Le risorse sono definite in un modello, visualizzabile nella [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nome di dominio***: un nome di dominio che indirizza alla tua app Web nel modulo. {{subdomain}} {{region}}.elasticbeanstalk.com*.
**Sicurezza del dominio**
Per aumentare la sicurezza delle tue applicazioni Elastic Beanstalk, il dominio *elasticbeanstalk.com* è registrato nella [Public Suffix List (PSL).](https://publicsuffix.org/)
Se hai bisogno di impostare cookie sensibili nel nome di dominio predefinito per le tue applicazioni Elastic Beanstalk, ti consigliamo di utilizzare i cookie `__Host-` con un prefisso per una maggiore sicurezza. Questa pratica difende il tuo dominio dai tentativi di falsificazione delle richieste tra siti (CSRF). Per ulteriori informazioni, consulta la pagina [Impostazione cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) nella pagina Mozilla Developer Network.
1. Quando la creazione dell'ambiente è completa, utilizza il comando [**eb open**](eb3-open.md) per aprire l'URL dell'ambiente nel browser predefinito.
```
~/nodejs-example-express-elasticache$ eb open
```
È stato ora creato un ambiente Elastic Beanstalk Node.js con un'applicazione di esempio. A questo punto puoi aggiornarlo con la tua applicazione. Successivamente, aggiorniamo l'applicazione di esempio per utilizzare il framework Express.
## Aggiornamento dell'applicazione per usare Express
Aggiornare l'applicazione di esempio nell'ambiente Elastic Beanstalk per utilizzare il framework Express.
[Puoi scaricare il codice sorgente finale da .zip. nodejs-example-express-elasticache](samples/nodejs-example-express-elasticache.zip)
**Per aggiornare l'applicazione per usare Express**
Una volta creato un ambiente con un'applicazione di esempio, potrai aggiornarlo con la tua applicazione. In questa procedura, eseguiamo innanzitutto i comandi **express** e **npm install** per configurare il framework Express nella directory dell'applicazione.
1. Esegui il comando `express`. Questo genera `package.json`, `app.js` e poche altre directory.
```
~/nodejs-example-express-elasticache$ express
```
Quando ti viene chiesto se desideri proseguire, digita **y**.
**Nota**
Se il comando **express** non funziona, è possibile che non sia stato installato il generatore di riga di comando Express come descritto nella precedente sezione *Prerequisiti*. Oppure potrebbe essere necessario configurare l'impostazione del percorso della directory per il computer locale in modo da eseguire il comando **express**. Consulta la sezione *Prerequisiti* per i passaggi dettagliati sulla configurazione dell'ambiente di sviluppo, in modo da poter procedere con questo tutorial.
1. Configura le dipendenze locali.
```
~/nodejs-example-express-elasticache$ npm install
```
1. (Facoltativo) Verifica dell'avvio del server dell'applicazione Web.
```
~/nodejs-example-express-elasticache$ npm start
```
Verrà visualizzato un output simile al seguente:
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
Il server viene eseguito sulla porta 3000 per impostazione predefinita. Per testarlo, esegui `curl http://localhost:3000` su un altro terminale oppure apri un browser sul computer locale e immetti l'indirizzo URL `http://localhost:3000`.
Premi **Ctrl\+C** per arrestare il server.
1. Rinomina `nodejs-example-express-elasticache/app.js` come `nodejs-example-express-elasticache/express-app.js`.
```
~/nodejs-example-express-elasticache$ mv {{app.js express-app.js}}
```
1. Aggiornare la riga `var app = express();` in `nodejs-example-express-elasticache/express-app.js` sui seguenti elementi.
```
var app = module.exports = express();
```
1. Sul computer locale, creare un file denominato `nodejs-example-express-elasticache/app.js` con il seguente codice.
```
/**
* 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. Sostituisci il contenuto del file `nodejs-example-express-elasticache/bin/www` con quanto riportato di seguito:
```
#!/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. Implementa le modifiche apportate all'ambiente Elastic Beanstalk con il comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-elasticache$ eb deploy
```
1. Il tuo ambiente sarà aggiornato dopo qualche minuto. Quando l'ambiente è verde e pronto, aggiorna l'URL per verificare che funziona. Visualizzerai una pagina Web con la dicitura Welcome to Express (Benvenuto in Express).
Puoi accedere ai log per le Istanza EC2 che eseguono l'applicazione. Per istruzioni su come accedere ai log, consulta [Visualizzazione dei log delle istanze Amazon EC2 nell'ambiente Elastic Beanstalk](using-features.logging.md).
Successivamente, aggiorniamo l'applicazione Express per utilizzare Amazon ElastiCache.
**Per aggiornare la tua applicazione Express per utilizzare Amazon ElastiCache**
1. Sul computer locale, creare una directory `.ebextensions` nella directory di primo livello del bundle di origine. In questo esempio viene utilizzato `nodejs-example-express-elasticache/.ebextensions`.
1. Creare un file di configurazione `nodejs-example-express-elasticache/.ebextensions/elasticache-iam-with-script.config` con il seguente snippet. Per ulteriori informazioni sul file di configurazione, consulta [Spazi dei nomi per la configurazione di Node.js](create_deploy_nodejs.container.md#nodejs-namespaces). In questo modo viene creato un utente IAM con le autorizzazioni necessarie per scoprire i nodi elasticache e le operazioni di scrittura su un file a ogni modifica della cache. Puoi anche copiare il file [nodejs-example-express-elasticacheda.zip.](samples/nodejs-example-express-elasticache.zip) Per ulteriori informazioni sulle ElastiCache proprietà, vedere[Esempio: ElastiCache](customize-environment-resources-elasticache.md).
**Nota**
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
```
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. Sul computer locale, create un file di configurazione `nodejs-example-express-elasticache/.ebextensions/elasticache_settings.config` con il seguente frammento di codice da configurare. ElastiCache
```
option_settings:
"aws:elasticbeanstalk:customoption":
CacheNodeType: cache.t2.micro
NumCacheNodes: 1
Engine: memcached
NodeListPath: /var/nodelist
```
1. Sul computer locale, sostituire `nodejs-example-express-elasticache/express-app.js` con lo snippet seguente. Questo file legge l'elenco dei nodi dal disco (`/var/nodelist`) e configura express per utilizzare `memcached` come uno store di sessione se sono presenti nodi. Il file avrà un aspetto simile al seguente.
```
/**
* 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. Sul computer locale, aggiorna `package.json` con i seguenti contenuti:
```
"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. Esegui **npm install**.
```
~/nodejs-example-express-elasticache$ npm install
```
1. Distribuisci l'applicazione aggiornata.
```
~/nodejs-example-express-elasticache$ eb deploy
```
1. Il tuo ambiente sarà aggiornato dopo qualche minuto. Quando l'ambiente è verde e pronto, verificare che il codice abbia funzionato.
1. Controlla la [ CloudWatch console Amazon](https://console.aws.amazon.com/cloudwatch/home) per visualizzare le tue ElastiCache metriche. Per visualizzare le tue ElastiCache metriche, seleziona **Metriche** nel riquadro a sinistra, quindi cerca. **CurrItems** Seleziona **ElastiCache > Metriche del nodo di cache**, quindi seleziona il nodo di cache per visualizzare il numero di elementi nella cache.
**Nota**
Verifica di fare riferimento alla stessa regione in cui hai distribuito la tua applicazione.
Se copi e incolli l'URL dell'applicazione in un altro browser Web e aggiorni la pagina, dovresti vedere il CurrItem conteggio aumentare dopo 5 minuti.
1. Acquisire uno snapshot dei log. Per ulteriori informazioni sul recupero di oggetti, consulta [Visualizzazione dei log delle istanze Amazon EC2 nell'ambiente Elastic Beanstalk](using-features.logging.md).
1. Selezionare il file `/var/log/nodejs/nodejs.log` nel bundle dei log. Dovrebbe essere visualizzato un output simile al seguente:
```
Using memcached store nodes:
[ 'aws-my-1oys9co8zt1uo.1iwtrn.0001.use1.cache.amazonaws.com:11211' ]
```
## Elimina
Se non desideri più eseguire l'applicazione, puoi chiudere il tuo ambiente ed eliminarla.
Utilizza il comando `eb terminate` per chiudere il tuo ambiente e il comando `eb delete` per eliminare l'applicazione.
**Per terminare l'ambiente**
Nella directory in cui hai creato il tuo repository locale, esegui `eb terminate`.
```
$ eb terminate
```
Questo processo può richiedere alcuni minuti. Elastic Beanstalk visualizza un messaggio non appena l'ambiente viene chiuso correttamente.