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 applicazioni Node.js con Elastic Beanstalk
Questo capitolo fornisce istruzioni per configurare e distribuire l'applicazione Web Node.js su. AWS Elastic Beanstalk Fornisce inoltre procedure dettagliate per attività comuni come l'integrazione del database e l'utilizzo del framework Express. Elastic Beanstalk semplifica la distribuzione, la gestione e la scalabilità delle applicazioni Web Node.js utilizzando Amazon Web Services.
Puoi distribuire la tua applicazione in pochi minuti utilizzando l'Elastic Beanstalk Command Line Interface (EB CLI) o utilizzando la console Elastic Beanstalk. Dopo aver distribuito l'applicazione Elastic Beanstalk, puoi continuare a utilizzare l'EB CLI per gestire l'applicazione e l'ambiente, oppure puoi utilizzare la console Elastic Beanstalk o il. AWS CLI APIs
Segui le step-by-step istruzioni [QuickStart per Node.js](nodejs-quickstart.md) per creare e distribuire un'applicazione Web *Hello World* Node.js con l'EB CLI.
**Topics**
+ [QuickStart: distribuzione di un'applicazione Node.js su Elastic Beanstalk](nodejs-quickstart.md)
+ [Configurazione dell'ambiente di sviluppo Node.js per Elastic Beanstalk](nodejs-devenv.md)
+ [Utilizzo della piattaforma Node.js di Elastic Beanstalk](create_deploy_nodejs.container.md)
+ [Altri esempi di applicazioni e tutorial di Elastic Beanstalk per Node.js](nodejs-getstarted.md)
+ [Distribuzione di un'applicazione Node.js Express su Elastic Beanstalk](create_deploy_nodejs_express.md)
+ [Distribuzione di un'applicazione Node.js Express con clustering su Elastic Beanstalk](nodejs-express-clustering.md)
+ [Distribuzione di un'applicazione Node.js con DynamoDB in Elastic Beanstalk](nodejs-dynamodb-tutorial.md)
+ [Aggiungere un'istanza Amazon RDS DB all'ambiente Node.js Elastic Beanstalk](create-deploy-nodejs.rds.md)
+ [Strumenti e risorse Node.js](create_deploy_nodejs.resources.md)
# QuickStart: distribuzione di un'applicazione Node.js su Elastic Beanstalk
Questo QuickStart tutorial illustra il processo di creazione di un'applicazione Node.js e la sua distribuzione in un ambiente. AWS Elastic Beanstalk
**Non per uso in produzione**
Gli esempi sono solo a scopo dimostrativo. Non utilizzare applicazioni di esempio in produzione.
**Topics**
+ [Il tuo AWS account](#nodejs-quickstart-aws-account)
+ [Prerequisiti](#nodejs-quickstart-prereq)
+ [Passaggio 1: creare un'applicazione Node.js](#nodejs-quickstart-create-app)
+ [Passaggio 2: Esegui l'applicazione localmente](#nodejs-quickstart-run-local)
+ [Fase 3: Distribuire l'applicazione Node.js con l'EB CLI](#nodejs-quickstart-deploy)
+ [Fase 4: Esegui l'applicazione su Elastic Beanstalk](#nodejs-quickstart-run-eb-ap)
+ [Fase 5: rimozione](#go-tutorial-cleanup)
+ [AWS risorse per la tua applicazione](#nodejs-quickstart-eb-resources)
+ [Fasi successive](#nodejs-quickstart-next-steps)
+ [Esegui la distribuzione con la console Elastic Beanstalk](#nodejs-quickstart-console)
## Il tuo AWS account
Se non sei già AWS cliente, devi creare un AWS account. La registrazione ti consente di accedere a Elastic Beanstalk AWS e ad altri servizi di cui hai bisogno.
Se hai già un AWS account, puoi passare a. [Prerequisiti](#nodejs-quickstart-prereq)
### Crea un AWS account
#### Registrati per un Account AWS
Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.
**Per iscriverti a un Account AWS**
1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)
1. Segui le istruzioni online.
Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.
Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.
#### Crea un utente con accesso amministrativo
Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.
**Proteggi i tuoi Utente root dell'account AWS**
1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.
Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.
1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.
Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.
**Crea un utente con accesso amministrativo**
1. Abilita il Centro identità IAM.
Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.
1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.
Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.
**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.
Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.
**Assegnazione dell’accesso ad altri utenti**
1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.
Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.
1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).
Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.
## Prerequisiti
Per seguire le procedure in questa guida, devi usare un terminale a riga di comando o una shell per eseguire i comandi. I comandi vengono visualizzati in elenchi preceduti da un simbolo di prompt (\$1) e dal nome della directory corrente, se appropriato.
```
~/eb-project$ this is a command
this is output
```
Su Linux e macOS usa la tua shell e il tuo programma di gestione dei pacchetti preferiti. Su Windows puoi [installare il sottosistema Windows per Linux per](https://docs.microsoft.com/en-us/windows/wsl/install-win10) ottenere una versione integrata per Windows di Ubuntu e Bash.
### CLI EB
Questo tutorial utilizza l'interfaccia a riga di comando di Elastic Beanstalk (CLI EB). Per istruzioni dettagliate su come configurare e utilizzare la 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).
### Node.js
Installa Node.js sul tuo computer locale seguendo [Come installare Node.js](https://nodejs.org/en/learn/getting-started/how-to-install-nodejs) sul sito web Node.js.
Verifica l'installazione di Node.js eseguendo il comando seguente.
```
~$ node -v
```
## Passaggio 1: creare un'applicazione Node.js
Crea una directory di progetto.
```
~$ mkdir eb-nodejs
~$ cd eb-nodejs
```
Successivamente, crea un'applicazione che distribuirai utilizzando Elastic Beanstalk. Creeremo un servizio 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}/`);
});
```
Questa applicazione apre un listener sulla porta 8080. Elastic Beanstalk inoltra le richieste all'applicazione sulla porta 8080 per impostazione predefinita per Node.js.
## Passaggio 2: Esegui l'applicazione localmente
Esegui il comando seguente per eseguire l'applicazione localmente.
```
~/eb-nodejs$ node server.js
```
Dovresti vedere il testo seguente.
```
Server running at http://127.0.0.1:8080/
```
Inserisci l'indirizzo URL `http://127.0.0.1:8080/` nel tuo browser web. Il browser dovrebbe mostrare «Hello Elastic Beanstalk\$1».
## Fase 3: Distribuire l'applicazione Node.js con l'EB CLI
Esegui i seguenti comandi per creare un ambiente Elastic Beanstalk per questa applicazione.
**Per creare un ambiente e distribuire l'applicazione Node.js**
1. Inizializza il repository della CLI EB con il comando **eb init**.
```
~/eb-nodejs$ eb init -p node.js nodejs-tutorial --region us-east-2
```
Questo comando crea un'applicazione denominata `nodejs-tutorial` e configura il repository locale per creare ambienti con l'ultima versione della piattaforma Node.js.
1. (Facoltativo) Esegui **eb init** nuovamente per configurare una coppia di key pair predefinita in modo da poter utilizzare SSH per connetterti all' EC2 istanza che esegue l'applicazione.
```
~/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 ]
```
Seleziona una coppia di chiavi se ne hai già una, oppure segui le istruzioni per creare una nuova. Se il prompt non è visualizzato o devi modificare le impostazioni in seguito, esegui **eb init -i**.
1. Crea un ambiente e distribuisci in esso l'applicazione con **eb create**: Elastic Beanstalk crea automaticamente un file zip per l'applicazione e lo distribuisce in un'istanza dell'ambiente. EC2 Dopo aver distribuito l'applicazione, Elastic Beanstalk la avvia sulla porta 8080.
```
~/eb-nodejs$ eb create nodejs-env
```
Elastic Beanstalk impiega circa cinque minuti per creare l'ambiente.
## Fase 4: Esegui l'applicazione su Elastic Beanstalk
Una volta completato il processo di creazione dell'ambiente, apri il sito Web con. **eb open**
```
~/eb-nodejs$ eb open
```
Complimenti\$1 Hai distribuito un'applicazione Node.js con Elastic Beanstalk\$1 Si aprirà una finestra del browser che utilizza il nome di dominio creato per l'applicazione.
## Fase 5: rimozione
Puoi chiudere l'ambiente quando hai finito di lavorare con l'applicazione. Elastic Beanstalk AWS interrompe tutte le risorse associate all'ambiente.
Per terminare l'ambiente Elastic Beanstalk con l'EB CLI, esegui il comando seguente.
```
~/eb-nodejs$ eb terminate
```
## AWS risorse per la tua applicazione
Hai appena creato un'applicazione a istanza singola. Funge da semplice applicazione di esempio con una singola EC2 istanza, quindi non richiede il bilanciamento del carico o la scalabilità automatica. Per le applicazioni a istanza singola Elastic Beanstalk crea le seguenti risorse: AWS
+ **EC2 istanza**: una macchina EC2 virtuale Amazon configurata per eseguire app Web sulla piattaforma scelta.
Ogni piattaforma esegue un insieme diverso di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di tutti questi elementi. La maggior parte delle piattaforme utilizza Apache o nginx come proxy inverso che elabora il traffico web 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 dell'istanza**: un gruppo EC2 di sicurezza Amazon configurato per consentire il traffico in entrata sulla porta 80. Questa risorsa consente al traffico HTTP proveniente dal sistema di bilanciamento del carico di raggiungere l' EC2 istanza su cui è in esecuzione la tua app web. Per impostazione predefinita, il traffico non è consentito su altre porte.
+ **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 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*.
Elastic Beanstalk gestisce tutte queste risorse. Quando arresti l'ambiente, Elastic Beanstalk termina tutte le risorse che contiene.
## Fasi successive
Quando disponi di un'applicazione in esecuzione in un ambiente, puoi distribuire una nuova versione dell'applicazione o un'applicazione diversa in qualsiasi momento. La distribuzione di una nuova versione dell'applicazione è molto rapida perché non richiede il provisioning o il riavvio delle istanze. EC2 Puoi anche esplorare il tuo nuovo ambiente utilizzando la console Elastic Beanstalk. Per i passaggi dettagliati, consulta [Esplora il tuo ambiente](GettingStarted.md#GettingStarted.Explore) nel capitolo *Guida introduttiva* di questa guida.
**Prova altri tutorial**
Se desideri provare altri tutorial con diverse applicazioni di esempio, consulta. [Altri esempi di applicazioni e tutorial di Elastic Beanstalk per Node.js](nodejs-getstarted.md)
Dopo aver distribuito una o due applicazioni di esempio e essere pronti per iniziare a sviluppare ed eseguire le applicazioni Node.js localmente, consulta. [Configurazione dell'ambiente di sviluppo Node.js per Elastic Beanstalk](nodejs-devenv.md)
## Esegui la distribuzione con la console Elastic Beanstalk
Puoi anche utilizzare la console Elastic Beanstalk per avviare l'applicazione di esempio. Per i passaggi dettagliati, consulta [Creare un'applicazione di esempio](GettingStarted.md#GettingStarted.CreateApp) nel capitolo *Guida introduttiva* di questa guida.
# Configurazione dell'ambiente di sviluppo Node.js per Elastic Beanstalk
Questo argomento fornisce istruzioni per configurare un ambiente di sviluppo Node.js in cui testare l'applicazione localmente prima di distribuirla. AWS Elastic Beanstalk Fa inoltre riferimento a siti Web che forniscono istruzioni di installazione per strumenti utili.
**Topics**
+ [Installa Node.js](#nodejs-devenv-nodejs)
+ [Conferma l'installazione di npm](#nodejs-devenv-npm)
+ [Installa l' AWS SDK per Node.js](#nodejs-devenv-awssdk)
+ [Installazione del generatore Express](#nodejs-devenv-express)
+ [Configurazione di un framework e un server Express](#nodejs-devenv-express-framework)
## Installa Node.js
Installa Node.js per eseguire applicazioni Node.js in locale. Se non hai preferenze, scarica la versione più recente supportata da Elastic Beanstalk. consulta [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) nel documento relativo alle *Piattaforme AWS Elastic Beanstalk * per visionare un elenco delle versioni supportate.
Scarica Node.js all'indirizzo [nodejs.org](https://nodejs.org/en/).
## Conferma l'installazione di npm
Node.js utilizza un programma di gestione dei pacchetti npm che consente di installare strumenti e framework da utilizzare nell'applicazione. Poiché npm è distribuito con Node.js, verrà installato automaticamente quando si scarica e si installa Node.js. Per confermare l'installazione di npm è possibile eseguire il seguente comando:
```
$ npm -v
```
Per ulteriori informazioni su npm, visita il sito web [npmjs](https://www.npmjs.com/get-npm).
## Installa l' AWS SDK per Node.js
Se devi gestire AWS le risorse dall'interno dell'applicazione, installa l' AWS SDK for JavaScript in Node.js. Installazione dell'SDK con npm:
```
$ npm install aws-sdk
```
Per ulteriori informazioni, visita la home page di [AWS SDK for JavaScript in Node.js](https://aws.amazon.com/sdk-for-node-js/).
## Installazione del generatore Express
Express è un framework di applicazione Web in esecuzione su Node.js. Per usarlo, installa prima l'applicazione della riga di comando del generatore Express. Una volta installato il generatore Express, potrai eseguire il comando **express** per generare una struttura del progetto di base per la tua applicazione Web. Una volta installati il progetto di base, i file e le dipendenze, potrai avviare un server Express locale sul tuo computer di sviluppo.
**Nota**
I seguenti passaggi ti guideranno attraverso l'installazione del generatore Express su un sistema operativo Linux.
Per Linux, a seconda del livello di autorizzazione per le directory di sistema, potrebbe essere necessario aggiungere il prefisso `sudo` ad alcuni di questi comandi.
**Installazione del generatore Express nel tuo ambiente di sviluppo**
1. Crea una directory di lavoro per il tuo framework e server Express.
```
~$ mkdir node-express
~$ cd node-express
```
1. Installa Express globalmente per avere accesso al comando `express`.
```
~/node-express$ npm install -g express-generator
```
1. A seconda del sistema operativo, potrebbe essere necessario impostare il percorso per eseguire il comando `express`. Le informazioni sull'impostazione della variabile del percorso sono riportate nell'output del passo precedente. Di seguito è riportato un esempio per Linux.
```
~/node-express$ export PATH=$PATH:/usr/local/share/npm/bin/express
```
Seguendo i tutorial in questo capitolo, dovrai eseguire il comando **express** da diverse directory. Ogni tutorial imposta una struttura di progetto Express di base nella propria directory.
A questo punto hai installato il generatore della riga di comando Express da usare per creare una directory di framework per la tua applicazione Web, configurare le dipendenze e avviare il server delle app Web. Successivamente, completeremo i passaggi per eseguire questa operazione nella directory `node-express` che abbiamo creato.
## Configurazione di un framework e un server Express
Completa la seguente procedura per creare le directory e i contenuti del framework Express di base. I tutorial di questo capitolo includono anche questi passaggi per configurare il framework Express di base in ciascuna delle directory delle applicazioni del tutorial.
**Configurazione di un framework e un server Express**
1. Esegui il comando `express`. Questo genera `package.json`, `app.js` e poche altre directory.
```
~/node-express$ express
```
Quando ti viene chiesto se desideri proseguire, digita **y**.
1. Configura le dipendenze locali.
```
~/node-express$ npm install
```
1. Verifica dell'avvio del server dell'applicazione Web.
```
~/node-express$ 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\$1C** per arrestare il server.
# Utilizzo della piattaforma Node.js di Elastic Beanstalk
Questo argomento descrive come configurare, creare ed eseguire le applicazioni Node.js su Elastic Beanstalk.
AWS Elastic Beanstalk supporta una serie di rami di piattaforma per diverse versioni del linguaggio di programmazione Node.js. Per un elenco completo, consulta [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) nel documento *AWS Elastic Beanstalk Platforms*.
Elastic Beanstalk fornisce le [opzioni di configurazione](command-options.md) che puoi utilizzare per personalizzare il software in esecuzione sulle istanze EC2 nell'ambiente Elastic Beanstalk. È possibile [configurare le variabili di ambiente](environments-cfg-softwaresettings.md#environments-cfg-softwaresettings-console) necessarie per l'applicazione, abilitare la rotazione dei log su Amazon S3 e mappare le cartelle nel codice sorgente dell'applicazione che contengono i file statici ai percorsi serviti dal server proxy.
Sono disponibili opzioni di configurazione specifiche della piattaforma nella console Elastic Beanstalk per la [modifica della configurazione di un ambiente in esecuzione](environment-configuration-methods-after.md). Per conservare la configurazione dell'ambiente una volta terminata, puoi utilizzare [configurazioni salvate](environment-configuration-savedconfig.md) per salvare le impostazioni e applicarle successivamente a un altro ambiente.
Per salvare le impostazioni nel codice sorgente, puoi includere i [file di configurazione](ebextensions.md). Le impostazioni nei file di configurazione vengono applicate ogni volta che crei un ambiente o distribuisci l'applicazione. Puoi inoltre utilizzare i file di configurazione per installare pacchetti, eseguire script o altre operazioni di personalizzazione delle istanze durante le distribuzioni.
Puoi [includere un file `Package.json`](nodejs-platform-dependencies.md#nodejs-platform-packagejson) nel bundle di origine per installare i pacchetti durante l'implementazione, per fornire un comando start e per specificare la versione di Node.js che desideri sia utilizzata dall'applicazione. Puoi includere un [file `npm-shrinkwrap.json`](nodejs-platform-shrinkwrap.md) per bloccare le versioni delle dipendenze.
La piattaforma Node.js include un server proxy che serve asset statici, inoltra il traffico verso la tua applicazione e comprime le risposte. Puoi [estendere o sostituire la configurazione proxy predefinita](nodejs-platform-proxy.md) per scenari avanzati.
Ci sono diverse opzioni per avviare l'applicazione. Puoi aggiungere un [Procfile](nodejs-configuration-procfile.md) al tuo bundle di origine per specificare il comando che avvia l'applicazione. Quando non fornisci un `Procfile` ma specifichi un file `package.json`, Elastic Beanstalk esegue `npm start`. Se non viene fornito, Elastic Beanstalk cerca il file `app.js` o `server.js`, in questo ordine, e lo esegue.
Le impostazioni applicate nella console Elastic Beanstalk sostituiscono le stesse impostazioni nei file di configurazione, se esistenti. Ciò ti consente di disporre di impostazioni predefinite nei file di configurazione, sostituibili con impostazioni specifiche per l'ambiente nella console. Per ulteriori informazioni sulla precedenza e altri metodi di modifica delle impostazioni, consulta [Opzioni di configurazione](command-options.md).
Per informazioni dettagliate sui vari modi in cui è possibile estendere una piattaforma Elastic Beanstalk basata su Linux, consulta [Estensione delle piattaforme Elastic Beanstalk Linux](platforms-linux-extend.md).
## Configurazione dell'ambiente Node.js
Le impostazioni della piattaforma Node.js consentono di ottimizzare il comportamento delle istanze Amazon EC2. Puoi modificare la configurazione dell'istanza Amazon EC2 dell'ambiente Elastic Beanstalk utilizzando la console Elastic Beanstalk.
Utilizza la console Elastic Beanstalk per attivare la rotazione dei log in Amazon S3 e configurare variabili che l'applicazione è in grado di leggere dall'ambiente.
**Configurazione dell'ambiente Node.js nella console Elastic Beanstalk**
1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS
1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.
1. Nel riquadro di navigazione, seleziona **Configuration** (Configurazione).
1. Nella categoria di configurazione **Updates, monitoring, and logging** (Aggiornamenti, monitoraggio e registrazione), scegli **Edit** (Modifica).
### Opzioni del contenitore
È possibile specificare le seguenti opzioni specifiche della piattaforma:
+ **Proxy server (Server proxy)**: il server proxy da utilizzare nelle istanze dell'ambiente. Per impostazione predefinita, viene utilizzato NGINX.
### Opzioni di log
La sezione **Log Options (Opzioni di log)** ha due impostazioni:
+ **Instance profile** (Profilo dell'istanza): specifica il profilo dell'istanza che dispone dell'autorizzazione ad accedere al bucket Amazon S3 associato all'applicazione.
+ **Enable log file rotation to Amazon S3** (Abilita rotazione file di log in Amazon S3): specifica se i file di log per le istanze Amazon EC2 dell'applicazione debbano essere copiati nel bucket Amazon S3 associato all'applicazione.
### File statici
Per migliorare le prestazioni, la sezione **Static files** (File statici) consente di configurare il server proxy affinché fornisca file statici (ad esempio, HTML o immagini) da un set di directory all'interno dell'applicazione Web. Per ogni directory, è possibile impostare il percorso virtuale per la mappatura delle directory. Quando il server proxy riceve una richiesta da un file nel percorso specificato, questo serve il file direttamente anziché instradare la richiesta all'applicazione.
Per informazioni dettagliate sulla configurazione di file statici utilizzando file di configurazione o la console Elastic Beanstalk, consulta [Fornire i file statici](environment-cfg-staticfiles.md).
### Proprietà dell'ambiente
La sezione **Environment Properties** (Proprietà ambiente) consente di specificare le impostazioni di configurazione dell'ambiente nelle istanze Amazon EC2 che eseguono l'applicazione. Queste impostazioni sono passate come coppie chiave-valore all'applicazione.
All'interno dell'Node.jsambiente in cui viene eseguito AWS Elastic Beanstalk, è possibile accedere alle variabili di ambiente eseguendo`process.env.ENV_VARIABLE`.
```
var endpoint = process.env.API_ENDPOINT
```
La piattaforma Node.js imposta la variabile di ambiente PORT sulla porta a cui il server proxy trasferisce il traffico. Per ulteriori informazioni, consulta [Configurazione del server proxy](nodejs-platform-proxy.md).
Per ulteriori informazioni, consulta [Variabili di ambiente e altre impostazioni software](environments-cfg-softwaresettings.md).
### Configurazione di un ambiente Node.js per l'AMI Amazon Linux (precedente ad Amazon Linux 2)
Le seguenti categorie di configurazione del software della console sono supportate solo in un ambiente Node.js di Elastic Beanstalk che utilizza una versione della piattaforma AMI Amazon Linux (precedente ad Amazon Linux 2).
**Note**
Le informazioni contenute in questo argomento si applicano solo ai rami della piattaforma basati su Amazon Linux AMI (AL1). AL2023I rami AL2 della piattaforma/sono incompatibili con le versioni precedenti della piattaforma Amazon Linux AMI (AL1) e *richiedono impostazioni di configurazione diverse*.
[Il 18 luglio 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux AMI AL1 () come ritirato.** Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).
#### Opzioni del contenitore: Amazon Linux AMI (AL1)
Nella pagina di configurazione specifica le informazioni seguenti:
+ **Proxy server** (Server proxy): specifica il server Web da utilizzare per le connessioni proxy a Node.js. Per impostazione predefinita, viene utilizzato NGINX. Se selezioni **none**, (nessuno), le mappature dei file statici non vengono applicate e la compressione GZIP è disabilitata.
+ **Versione di Node.js**: specifica la versione di Node.js. Per un elenco delle versioni di Node.js supportate, consulta [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) nella guida *Piattaforme AWS Elastic Beanstalk *.
+ **Compressione GZIP**: specifica se la compressione GZIP è abilitata. Per impostazione predefinita, la compressione GZIP è abilitata.
+ **Node command** (Comando nodo): consente di immettere il comando utilizzato per avviare l'applicazione Node.js. Una stringa vuota (impostazione predefinita) indica che Elastic Beanstalk usa`app.js`, quindi `server.js` e poi `npm start`.
## Spazi dei nomi per la configurazione di Node.js
È possibile utilizzare un [file di configurazione](ebextensions.md) per impostare le opzioni di configurazione ed eseguire alte attività di configurazione delle istanze durante le distribuzioni. Le opzioni di configurazione possono essere [specifiche della piattaforma](command-options-specific.md) o essere applicate a [tutte le piattaforme](command-options-general.md) del servizio Elastic Beanstalk nel suo complesso. *Le opzioni di configurazione sono organizzate in namespace.*
È possibile scegliere il proxy da utilizzare nelle istanze dell'ambiente utilizzando lo spazio dei nomi `aws:elasticbeanstalk:environment:proxy`. L'esempio seguente configura l'ambiente in modo da utilizzare il server proxy HTTPD di Apache.
**Example .ebextensions/nodejs-settings.config**
```
option_settings:
aws:elasticbeanstalk:environment:proxy:
ProxyServer: apache
```
È possibile configurare il proxy per servire file statici utilizzando lo spazio dei nomi `aws:elasticbeanstalk:environment:proxy:staticfiles`. Per ulteriori informazioni e un esempio, consulta [Fornire i file statici](environment-cfg-staticfiles.md).
In Elastic Beanstalk sono disponibili varie opzioni di configurazione per la personalizzazione dell'ambiente. Oltre ai file di configurazione, puoi impostare le opzioni di configurazione tramite la console, le configurazioni salvate, la CLI EB o AWS CLI. Per ulteriori informazioni, consulta [Opzioni di configurazione](command-options.md).
## La piattaforma Node.js dell'AMI Amazon Linux (precedente ad Amazon Linux 2)
Se il tuo ambiente Node.js di Elastic Beanstalk utilizza una versione della piattaforma AMI Amazon Linux (precedente ad Amazon Linux 2), considera le configurazioni e i suggerimenti specifici in questa sezione.
**Note**
Le informazioni contenute in questo argomento si applicano solo ai rami della piattaforma basati su Amazon Linux AMI (AL1). AL2023I rami AL2 della piattaforma/sono incompatibili con le versioni precedenti della piattaforma Amazon Linux AMI (AL1) e *richiedono impostazioni di configurazione diverse*.
[Il 18 luglio 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux AMI AL1 () come ritirato.** Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).
### Node.jsopzioni di configurazione specifiche della piattaforma — Amazon Linux AMI () AL1
Elastic Beanstalk supporta alcune opzioni di configurazione specifiche della piattaforma per le versioni della piattaforma Node.js dell'AMI Amazon Linux. Puoi scegliere su quale server proxy eseguire l'applicazione, una versione specifica di Node.js da eseguire e il comando utilizzato per eseguire l'applicazione.
Per il server proxy, puoi utilizzare un NGINX o Apache. È possibile impostare il valore `none` sull'opzione `ProxyServer`. In questo caso, Elastic Beanstalk esegue l'applicazione come standalone, ossia non dietro un server proxy. Se l'ambiente esegue un'applicazione autonoma, aggiorna il codice per ascoltare sulla porta su cui NGINX inoltra il traffico.
```
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log('Server running at http://127.0.0.1:%s', port);
});
```
### Node.jsversioni linguistiche — Amazon Linux AMI (AL1)
In termini di versione del linguaggio supportata, la piattaforma Node.js dell'AMI Amazon Linux è leggermente diversa rispetto ad altre piattaforme gestite da Elastic Beanstalk. Questo perché ogni versione della piattaforma Node.js supporta solo alcune versioni del linguaggio Node.js. Per un elenco delle versioni di Node.js supportate, consulta [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) nella guida *Piattaforme AWS Elastic Beanstalk *.
Puoi utilizzare un'opzione di configurazione specifica della piattaforma per impostare la versione del linguaggio. Per istruzioni, consulta [Configurazione dell'ambiente Node.js](#nodejs-platform-console). In alternativa, utilizza la console Elastic Beanstalk per aggiornare la versione di Node.js usata dall'ambiente come parte dell'aggiornamento della versione della piattaforma.
**Nota**
Quando il supporto della versione di Node.js in uso viene rimosso dalla piattaforma, è necessario modificare o rimuovere l'impostazione della versione prima di eseguire un [aggiornamento della piattaforma](using-features.platform.upgrade.md). Questo può verificarsi quando viene rilevata una vulnerabilità di sicurezza per una o più versioni di Node.js
Quando ciò accade, il tentativo di aggiornamento a una nuova versione della piattaforma che non supporta quella configurata [NodeVersion](command-options-specific.md#command-options-nodejs)fallisce. Per evitare di dover creare un nuovo ambiente, modificate l'opzione di *NodeVersion*configurazione impostando una versione di Node.js supportata sia dalla vecchia versione della piattaforma che da quella nuova, oppure [rimuovete l'impostazione dell'opzione](environment-configuration-methods-after.md) e quindi eseguite l'aggiornamento della piattaforma.
**Configurazione della versione di Node.jsdell'ambiente nella console Elastic Beanstalk**
1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS
1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.
1. Nella pagina panoramica dell'ambiente, in **Platform (Piattaforma)**, scegliere **Change (Cambia)**.
1. Nella finestra di dialogo **Update platform version** (Aggiorna versione piattaforma), seleziona una versione di Node.js.
![\[Conferma della versione di aggiornamento della piattaforma Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/platform-nodejs-update-node-version.png)
1. Scegli **Save** (Salva).
### Node.jsnamespace di configurazione — Amazon Linux AMI () AL1
La piattaforma Node.js dell'AMI Amazon Linux definisce le opzioni aggiuntive negli spazi dei nomi `aws:elasticbeanstalk:container:nodejs:staticfiles` e `aws:elasticbeanstalk:container:nodejs`.
Il seguente file di configurazione indica a Elastic Beanstalk di utilizzare `npm start` per eseguire l'applicazione. Inoltre, imposta il tipo di proxy su Apache e abilita la compressione. Infine, configura il proxy per servire file statici da due directory fonte. Una origine è costituita da file HTML nel percorso `html` nella root del sito Web dalla directory di origine `statichtml`. L'altra fonte è costituita da file di immagine sul percorso `images` sotto la directory principale del sito Web dalla directory fonte `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
```
In Elastic Beanstalk sono disponibili varie opzioni di configurazione per la personalizzazione dell'ambiente. Oltre ai file di configurazione, puoi impostare le opzioni di configurazione tramite la console, le configurazioni salvate, la CLI EB o AWS CLI. Per ulteriori informazioni, consulta [Opzioni di configurazione](command-options.md).
# Configurazione di comandi di avvio personalizzati con un Elastic Procfile Beanstalk
Puoi includere un file chiamato `Procfile` nella root del pacchetto di origine per specificare il comando che avvia l'applicazione.
**Example Procfile**
```
web: node index.js
```
Per informazioni sull'`Procfile`utilizzo, consulta. [Buildfile e Procfile](platforms-linux-extend.build-proc.md)
**Nota**
Questa funzionalità sostituisce l'opzione legacy `NodeCommand` nello spazio dei nomi `aws:elasticbeanstalk:container:nodejs`.
# Configurazione delle dipendenze dell'applicazione su Elastic Beanstalk
L'applicazione potrebbe avere dipendenze su alcuni moduli Node.js, come quelli specificati nelle istruzioni `require()`. Questi moduli sono archiviati in una directory `node_modules`. Quando l'applicazione viene eseguita, Node.js carica i moduli da questa directory. Per ulteriori informazioni, consulta [Caricamento dalle cartelle node\$1modules](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders) nella documentazione di Node.js.
È possibile specificare queste dipendenze del modulo utilizzando un file `package.json`. Se Elastic Beanstalk rileva questo file e non è presente una directory `node_modules`, Elastic Beanstalk esegue `npm install` come utente *webapp*. Il comando `npm install` installa le dipendenze nella directory `node_modules`, che Elastic Beanstalk crea in precedenza. Il comando `npm install` accede ai pacchetti elencati nel file `package.json` dal registro pubblico di npm o da altre posizioni. Per ulteriori informazioni, consulta il sito Web della [documentazione di npm](https://docs.npmjs.com/about-the-public-npm-registry).
Se Elastic Beanstalk rileva la directory `node_modules`, allora non esegue `npm install` anche se esiste un file `package.json`. Elastic Beanstalk presuppone che i pacchetti di dipendenza siano disponibili nella directory `node_modules` perché Node.js possa accedere ed eseguire il caricamento.
Nelle sezioni seguenti vengono fornite ulteriori informazioni sulla definizione delle dipendenze tra moduli Node.js per l'applicazione.
**Nota**
Se quando Elastic Beanstalk esegue `npm install` si verificano dei problemi di implementazione, prendi in considerazione un approccio alternativo. Includi la directory `node_modules` con i moduli di dipendenza nel bundle di origine dell'applicazione. In questo modo è possibile aggirare i problemi relativi all'installazione delle dipendenze dal registro pubblico di npm mentre si esamina il problema. Poiché i moduli di dipendenza provengono da una directory locale, ciò potrebbe anche aiutare a ridurre i tempi di implementazione. Per ulteriori informazioni, consulta [Inclusione delle dipendenze Node.js in una directory node\$1modules](#nodejs-platform-nodemodules)
## Specifica delle dipendenze Node.js con un file package.json
Utilizza un file `package.json` nella root fonte del progetto per specificare i pacchetti di dipendenza e per fornire un comando start. Quando è presente un file `package.json` e una directory `node_modules` non è presente nella root dell'origine del progetto, Elastic Beanstalk esegue `npm install` come utente *webapp* per installare le dipendenze dal registro pubblico di npm. Elastic Beanstalk utilizza anche il comando `start` per avviare l'applicazione. Per ulteriori informazioni sul file `package.json`, consulta [Specifica delle dipendenze in un file `package.json`](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file) sul sito Web della *documentazione di npm*.
Usa la parola chiave `scripts` per dare un comando di avvio. La parola chiave `scripts` viene ora utilizzata al posto dell'opzione `NodeCommand` legacy nello spazio dei nomi `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"
}
}
```
**Dipendenze tra modalità di produzione e sviluppo**
Per specificare le dipendenze nel file `package.json`, usa gli attributi *dependencies* e *devDependencies*. L'attributo *dependencies* indica i pacchetti richiesti dall'applicazione in produzione. L'attributo *devDependencies* indica i pacchetti necessari solo per lo sviluppo e il test locali.
Se è necessario installare i pacchetti *devDependencies*, imposta la proprietà di ambiente NPM\$1USE\$1PRODUCTION su `false`. Con questa impostazione, durante l'esecuzione di npm install non verranno utilizzate le opzioni precedenti. Ciò comporterà l'installazione dei pacchetti *devDependencies*.
## Inclusione delle dipendenze Node.js in una directory node\$1modules
Per distribuire pacchetti di dipendenza nelle istanze di ambiente insieme al codice dell'applicazione, includili in una directory denominata `node_modules` nella directory root fonte del progetto. Per ulteriori informazioni, consulta [Download e installazione dei pacchetti in locale](https://docs.npmjs.com/downloading-and-installing-packages-locally) sul sito Web della *documentazione di npm*.
[Quando distribuisci una `node_modules` directory in una versione della AL2 Node.js piattaforma AL2023/, Elastic Beanstalk presume che tu stia fornendo i tuoi pacchetti di dipendenze ed evita di installare le dipendenze specificate in un file package.json.](#nodejs-platform-packagejson) Node.jscerca le dipendenze nella directory`node_modules`. Per ulteriori informazioni, consulta [Caricamento dalle cartelle node\$1modules](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders) nella documentazione di Node.js.
**Nota**
Se quando Elastic Beanstalk esegue `npm install` si verificano problemi di implementazione, considera l'utilizzo dell'approccio descritto in questo argomento come soluzione alternativa mentre analizzi il problema.
### Considerazioni per Node.js su Amazon Linux 2
Leggi questa sezione se utilizzi un ramo della piattaforma *Node.js* in esecuzione su *Amazon Linux 2*.
#### Considerazioni per Node.js su Amazon Linux 2
**Nota**
Le informazioni contenute in questo argomento si applicano ai rami Node.js della piattaforma in esecuzione su Amazon Linux 2. Il contenuto qui descrive caratteristiche e comportamenti AL2 specifici che differiscono da. AL2023
**Varianti dei comandi**
Le opzioni di comando variano a seconda della versione di npm inclusa nel ramo della piattaforma Amazon Linux 2 su cui viene eseguita l'applicazione.
+ npm v6: per impostazione predefinita, Elastic Beanstalk installa le dipendenze in modalità di produzione. Usa il comando `npm install --production`.
+ npm v7 o superiore: Elastic Beanstalk omette *devDependencies*. Usa il comando `npm install --omit=dev`.
Entrambi i comandi sopra elencati non installano i pacchetti che sono *devDependencies*.
**Protocolli SSH e HTTPS per le dipendenze Git**
A partire dalla versione della piattaforma Amazon Linux 2 del 7 marzo 2023, puoi utilizzare i protocolli SSH e HTTPS per recuperare i pacchetti da un repository Git. La ramificazione della piattaforma Node.js 16 supporta entrambi i protocolli SSH e HTTPS. Node.js 14 supporta solo il protocollo HTTPS.
**Example package.json: Node.js 16 supporta sia HTTPS che 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"
}
```
**Versioni e gamme di versioni**
Utilizza la parola chiave `engines` nel file `package.json` per specificare la versione di Node.js che desideri venga usata dalla tua applicazione. È inoltre possibile specificare un intervallo di versioni utilizzando la notazione npm. Per ulteriori informazioni sulla sintassi per gli intervalli di versioni, consulta [Controllo delle versioni della semantica tramite npm](https://nodejs.dev/learn/semantic-versioning-using-npm) sul sito Web di Node.js. La parola chiave `engines` nel file `package.json` di Node.js sostituisce l'opzione `NodeVersion` legacy nello spazio dei nomi `aws:elasticbeanstalk:container:nodejs`.
**Importante**
La funzionalità per specificare gli intervalli di versioni non è disponibile per i rami della piattaforma Node.js in esecuzione. AL2023 Supportiamo solo una versione di Node.js all'interno di uno specifico ramo Node.js su AL2023. Se il file `package.json` specifica un intervallo di versioni, lo ignoreremo e per impostazione predefinita verrà impostata la ramificazione della piattaforma di Node.js.
**Example `package.json`: la singola versione di Node.js**
```
{
...
"engines": { "node" : "14.16.0" }
}
```
**Example `package.json`: la gamma di versioni di Node.js**
```
{
...
"engines": { "node" : ">=10 <11" }
}
```
Quando viene indicato un intervallo di versioni, Elastic Beanstalk installa nell'intervallo l'ultima versione Node.js disponibile sulla piattaforma. In questo esempio, l'intervallo indica che la versione deve essere maggiore o uguale alla versione 10, ma inferiore alla versione 11. Di conseguenza, Elastic Beanstalk installa l'ultima versione 10.x.y di Node.js, disponibile sulla [piattaforma supportata](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs).
Tieni presente che è possibile specificare solo una versione di Node.js corrispondente al ramo della piattaforma. Ad esempio, se utilizzi la ramificazione della piattaforma Node.js 16, sarà possibile specificare solo una versione 16.x.y di Node.js. È possibile utilizzare le opzioni dell'intervallo di versioni supportate da npm, per consentire una maggiore flessibilità. Per le versioni valide di Node.js per ogni ramo della piattaforma, consulta [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) nella guida *Piattaforme AWS Elastic Beanstalk *.
**Nota**
Quando il supporto della versione di Node.js in uso viene rimosso dalla piattaforma, è necessario modificare o rimuovere l'impostazione della versione di Node.js prima di eseguire un [aggiornamento della piattaforma](using-features.platform.upgrade.md). Questo può verificarsi quando viene rilevata una vulnerabilità di sicurezza per una o più versioni di Node.js
Quando ciò si verifica, i tentativi di aggiornamento della piattaforma a una nuova versione che non supporta la versione di Node.js configurata avranno esito negativo. Per evitare la necessità di creare un nuovo ambiente, modificare l'impostazione della versione Node.js in `package.json` a una versione Node.js supportata sia dalla vecchia versione della piattaforma che da quella nuova. È possibile specificare un intervallo di versioni Node.js che include una versione supportata, come descritto in precedenza in questo argomento. Hai anche la possibilità di rimuovere l'impostazione e quindi distribuire il nuovo bundle fonte.
# Blocco delle dipendenze con Elastic npm shrinkwrap Beanstalk
La piattaforma Node.js esegue `npm install` come utente *webapp* a ogni implementazione. Eventuali nuove versioni delle dipendenze disponibili vengono installate durante l'implementazione, che pertanto potrebbe richiedere molto tempo.
È possibile evitare l'upgrade delle dipendenze creando un file `npm-shrinkwrap.json` che blocca le dipendenze dell'applicazione alla versione corrente.
```
$ npm install
$ npm shrinkwrap
wrote npm-shrinkwrap.json
```
Includi questo file nel bundle di origine per essere sicuro che le dipendenze vengano installate una sola volta.
# Configurazione del server proxy
Elastic Beanstalk può utilizzare NGINX o HTTPD di Apache come proxy inverso per mappare l'applicazione al sistema di bilanciamento del carico di Elastic Load Balancing sulla porta 80. Il valore predefinito è NGINX. Elastic Beanstalk fornisce una configurazione proxy predefinita che puoi estendere o ignorare completamente in favore di quella personalizzata.
Per impostazione predefinita, Elastic Beanstalk configura il proxy per inoltrare le richieste all'applicazione sulla porta 5000. È possibile sostituire la porta predefinita impostando la `PORT`[proprietà dell'ambiente](create_deploy_nodejs.container.md#nodejs-platform-console) sulla porta di ascolto dell'applicazione principale.
**Nota**
La porta di ascolto della tua applicazione non influisce sulla porta che il server NGINX ascolta per ricevere le richieste dal sistema di bilanciamento del carico.
**Configurazione del server proxy sulla versione della piattaforma**
Tutte le AL2 piattaforme AL2023/supportano una funzionalità di configurazione proxy uniforme. Per ulteriori informazioni sulla configurazione del server proxy sulle versioni della piattaforma che eseguono AL2023/AL2, consulta[Configurazione del proxy inverso](platforms-linux-extend.proxy.md).
## Configurazione del proxy su AMI Amazon Linux (precedente ad Amazon Linux 2)
Se l'ambiente Node.js di Elastic Beanstalk utilizza una versione della piattaforma AMI Amazon Linux (precedente ad Amazon Linux 2), leggi le informazioni presenti in questa sezione.
**Note**
Le informazioni contenute in questo argomento si applicano solo ai rami della piattaforma basati su Amazon Linux AMI (AL1). AL2023I rami AL2 della piattaforma/sono incompatibili con le versioni precedenti della piattaforma Amazon Linux AMI (AL1) e *richiedono impostazioni di configurazione diverse*.
[Il 18 luglio 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux AMI AL1 () come ritirato.** Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).
### Estensione e sovrascrittura della configurazione proxy predefinita — Amazon Linux AMI () AL1
La piattaforma Node.js utilizza un proxy inverso per l'inoltro delle richieste provenienti dalla porta 80 dell'istanza all'applicazione in ascolto sulla porta 8081. Elastic Beanstalk fornisce una configurazione proxy predefinita che puoi estendere o ignorare completamente in favore di quella personalizzata.
Per estendere la configurazione predefinita, aggiungi file `.conf` a `/etc/nginx/conf.d` con un file di configurazione. Per un esempio specifico, consulta [Terminazione di HTTPS nelle istanze EC2 che eseguono Node.js](https-singleinstance-nodejs.md).
La piattaforma Node.js imposta la variabile di ambiente PORT sulla porta a cui il server proxy trasferisce il traffico. Leggi questa variabile nel codice per configurare la porta della tua applicazione.
```
var port = process.env.PORT || 3000;
var server = app.listen(port, function () {
console.log('Server running at http://127.0.0.1:' + port + '/');
});
```
La configurazione NGINX predefinita inoltra il traffico a un server upstream denominato `nodejs` su `127.0.0.1:8081`. È possibile rimuovere la configurazione predefinita e fornire quella personalizzata in un [file di configurazione](ebextensions.md).
**Example .ebextensions/proxy.config**
L'esempio seguente rimuove la configurazione predefinita e aggiunge una configurazione personalizzata che inoltra il traffico alla porta 5000 anziché alla porta 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"
```
La configurazione di esempio, `/etc/nginx/conf.d/proxy.conf`, utilizza la configurazione predefinita specificata in `/etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf` come base per includere il blocco di server predefinito con la compressione e le impostazioni dei log, nonché una mappatura di file statici.
Il comando `removeconfig` rimuove la configurazione predefinita per il container, in modo che il server proxy utilizzi la configurazione personalizzata. Elastic Beanstalk ricrea la configurazione predefinita una volta implementate tutte le configurazioni. Per tenere conto di ciò, nell'esempio seguente viene aggiunto un post-configuration-deployment hook (`/opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh`). In questo modo viene rimossa la configurazione predefinita e riavvia il server proxy.
**Nota**
La configurazione predefinita potrebbe cambiare nelle versioni future della piattaforma Node.js. Per garantire la compatibilità, utilizza la versione più recente della configurazione come base per le personalizzazioni.
Se sovrascrivi la configurazione predefinita, devi definire eventuali mappature di file statici e compressione GZIP. Questo perché la piattaforma non può applicare le [ impostazioni standard](create_deploy_nodejs.container.md#nodejs-namespaces).
# Altri esempi di applicazioni e tutorial di Elastic Beanstalk per Node.js
Questa sezione fornisce applicazioni e tutorial aggiuntivi. L'[QuickStart per Node.js](nodejs-quickstart.md)argomento riportato in precedenza in questo argomento illustra come avviare l'applicazione di esempio Node.js con l'EB CLI.
Per iniziare a utilizzare le applicazioni Node.js AWS Elastic Beanstalk, è sufficiente un [pacchetto di sorgenti](applications-sourcebundle.md) dell'applicazione da caricare come prima versione dell'applicazione e da distribuire in un ambiente.
## Avvio di un ambiente con un'applicazione Node.js di esempio
Elastic Beanstalk fornisce applicazioni di esempio a pagina singola per ogni piattaforma, nonché esempi più complessi che mostrano l'uso di risorse AWS aggiuntive come Amazon RDS e funzionalità specifiche del linguaggio o della piattaforma e. APIs
**Nota**
Segui i passaggi nel file del pacchetto di origine `README.md` per implementarlo.
**Esempi**
| Tipo di ambiente | Bundle di origine | Description |
| --- | --- | --- |
| Server Web | [nodejs.zip](samples/nodejs.zip) | Applicazione a pagina singola. Per avviare l'applicazione di esempio con l'EB CLI, vedere. [QuickStart per Node.js](nodejs-quickstart.md) Puoi anche utilizzare la console Elastic Beanstalk per avviare l'applicazione di esempio. Per i passaggi dettagliati, consulta [Creare un'applicazione di esempio](GettingStarted.md#GettingStarted.CreateApp) nel capitolo *Guida introduttiva* di questa guida. |
| Server Web con Amazon RDS | [nodejs-example-express-rds.zip](samples/nodejs-example-express-rds.zip) | Applicazione Hiking Log che usa il framework Express e un Amazon Relational Database Service (RDS). [Tutorial](create_deploy_nodejs_express.md) |
| Server Web con Amazon ElastiCache | [nodejs-example-express-elasticache.zip](samples/nodejs-example-express-elasticache.zip) | Applicazione web Express che utilizza Amazon ElastiCache per il clustering. Il clustering migliora l'alta disponibilità, le prestazioni e la sicurezza della tua applicazione Web. [Tutorial](nodejs-express-clustering.md) |
| Server Web con DynamoDB, Amazon SNS e Amazon SQS | [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) | Sito Web Express che consente di raccogliere informazioni di contatto degli utenti per una campagna di marketing di una nuova azienda. Utilizza l' AWS SDK for JavaScript in Node.js per scrivere voci in una tabella DynamoDB e i file di configurazione Elastic Beanstalk per creare risorse in DynamoDB, Amazon SNS e Amazon SQS. [Tutorial](nodejs-dynamodb-tutorial.md) |
## Fasi successive
Quando disponi di un'applicazione in esecuzione in un ambiente, puoi distribuire una nuova versione dell'applicazione o un'applicazione completamente diversa in qualsiasi momento. La distribuzione di una nuova versione dell'applicazione è molto veloce perché non richiede il provisioning o il riavvio delle istanze EC2. Per informazioni dettagliate sulla distribuzione dell'applicazione, consulta [Distribuzione di una nuova versione dell'applicazione](GettingStarted.md#GettingStarted.DeployApp).
Dopo aver distribuito una o due applicazioni di esempio e aver iniziato a sviluppare ed eseguire applicazioni Node.js localmente, consulta la procedura [Configurazione dell'ambiente di sviluppo Node.js per Elastic Beanstalk](nodejs-devenv.md) per configurare un ambiente di sviluppo Node.js con tutti gli strumenti necessari.
# Distribuzione di un'applicazione Node.js Express su Elastic Beanstalk
[Questa sezione illustra come distribuire un'applicazione di esempio su Elastic Beanstalk utilizzando l'Elastic Beanstalk Command Line Interface (EB CLI) e quindi aggiornare l'applicazione per utilizzare il framework Express.](http://expressjs.com/)
## 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 a cui si fa 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-rds` per il pacchetto sorgente dell'applicazione. Crea la directory `nodejs-example-express-rds` per questo tutorial.
```
~$ mkdir nodejs-example-express-rds
```
**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-rds`.
```
~$ cd nodejs-example-express-rds
```
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-rds$ 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-rds$ eb create --sample nodejs-example-express-rds
```
Questo comando crea un ambiente con bilanciamento del carico con le impostazioni predefinite per la piattaforma Node.js e le risorse seguenti:
+ **EC2 istanza**: una macchina virtuale Amazon Elastic Compute Cloud (Amazon EC2) configurata per eseguire 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 dell'istanza**: un gruppo EC2 di sicurezza Amazon configurato per consentire il traffico in entrata sulla porta 80. Questa risorsa consente al traffico HTTP proveniente dal sistema di bilanciamento del carico di raggiungere l' EC2 istanza su cui è in esecuzione la tua 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 Load Balancer: un gruppo** EC2 di sicurezza Amazon configurato per consentire 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-rds$ 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
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. Quindi usa la CLI EB per aggiornare l'ambiente Elastic Beanstalk con l'applicazione aggiornata.
**Per aggiornare l'applicazione per usare Express**
1. Esegui il comando `express`. Questo genera `package.json`, `app.js` e poche altre directory.
```
~/nodejs-example-express-rds$ 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-rds$ npm install
```
1. (Facoltativo) Verifica dell'avvio del server dell'applicazione Web.
```
~/nodejs-example-express-rds$ 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\$1C** per arrestare il server.
1. Implementa le modifiche apportate all'ambiente Elastic Beanstalk con il comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-rds$ eb deploy
```
1. 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)**.
Successivamente, aggiorniamo l'applicazione Express per distribuire i file statici e aggiungere una nuova pagina.
**Per configurare i file statici e aggiungere una nuova pagina all'applicazione Express**
1. Aggiungi un secondo file di configurazione nella cartella [`.ebextensions`](ebextensions.md) con il seguente contenuto:
**`nodejs-example-express-rds/.ebextensions/staticfiles.config`**
```
option_settings:
aws:elasticbeanstalk:environment:proxy:staticfiles:
/stylesheets: public/stylesheets
```
In base a questa configurazione il server proxy serve i file nella cartella `public` al percorso `/public` dell'applicazione. Servire i file staticamente dal proxy riduce il carico di lavoro per l'applicazione. Per ulteriori informazioni, consulta la sezione [File statici](create_deploy_nodejs.container.md#nodejs-platform-console-staticfiles) descritta precedentemente in questo capitolo.
1. (Facoltativo) Per essere certi che le mappature statiche siano configurate correttamente, commenta la configurazione della mappatura statica in `nodejs-example-express-rds/app.js`. Ciò rimuoverà la mappatura dall'applicazione del nodo.
```
// app.use(express.static(path.join(__dirname, 'public')));
```
Le mappature statiche del file `staticfiles.config` del passaggio precedente dovrebbero comunque caricare correttamente il foglio di stile anche dopo aver commentato questa riga. Per verificare che le mappature dei file statici vengano caricate tramite la configurazione del file statico del proxy anziché tramite l'applicazione Express, rimuovi i valori che seguono `option_settings:`. Una volta rimosso sia dalla configurazione del file statico che dall'applicazione del nodo, il foglio di stile non verrà caricato.
Una volta terminato il test, ricordati di reimpostare il contenuto di `nodejs-example-express-rds/app.js` e `staticfiles.config`.
1. Add `nodejs-example-express-rds/routes/hike.js`. Digita quanto segue:
```
exports.index = function(req, res) {
res.render('hike', {title: 'My Hiking Log'});
};
exports.add_hike = function(req, res) {
};
```
1. Aggiorna `nodejs-example-express-rds/app.js` per includere tre nuove righe.
In primo luogo, aggiungi la riga seguente per aggiungere un `require` a questo percorso:
```
var hike = require('./routes/hike');
```
Il file si presenta in maniera simile al seguente frammento:
```
var express = require('express');
var path = require('path');
var hike = require('./routes/hike');
```
Quindi, aggiungi le seguenti due righe a `nodejs-example-express-rds/app.js` dopo `var app = express();`
```
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
```
Il file si presenta in maniera simile al seguente frammento:
```
var app = express();
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
```
1. Copia `nodejs-example-express-rds/views/index.jade` su `nodejs-example-express-rds/views/hike.jade`.
```
~/nodejs-example-express-rds$ cp views/index.jade views/hike.jade
```
1. Implementa le modifiche con il comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-rds$ eb deploy
```
1. Il tuo ambiente sarà aggiornato dopo qualche minuto. Quando l'ambiente è verde e pronto, verifica che funzioni aggiornando il browser e aggiungendo **hikes** al termine dell'URL (ad esempio `http://node-express-env-syypntcz2q.elasticbeanstalk.com/hikes`).
Devi visualizzare una pagina Web intitolata **My Hiking Log (Il mio log di Hiking)**.
A questo punto, hai creato un'applicazione Web che utilizza il framework Express. Nella prossima sezione, modificheremo l'applicazione per utilizzare un Amazon Relational Database Service (RDS) per archiviare un log hiking.
## Aggiornamento dell'applicazione per usare Amazon RDS.
In questo passaggio successivo aggiorniamo l'applicazione in modo da utilizzare Amazon RDS per MySQL.
**Aggiornamento dell'applicazione per usare RDS per MySQL**
1. Per creare un database RDS per MySQL accoppiato all'ambiente Elastic Beanstalk, segui le istruzioni riportate nell'argomento [Aggiunta di un database](create-deploy-nodejs.rds.md) più avanti in questo capitolo. L'aggiunta di un'istanza del database richiede circa 10 minuti.
1. Aggiorna la sezione delle dipendenze nel file `package.json` con i seguenti contenuti:
```
"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. Esegui **npm install**.
```
~/nodejs-example-express-rds$ npm install
```
1. Aggiorna `app.js` per connetterti al database, creare una tabella e inserire un singolo log hiking predefinito. Ogni volta che questa app viene implementata, eliminerà la tabella di hiking precedente e la ricreerà.
```
/**
* 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. Aggiungi il seguente contenuto a `routes/hike.js`. Ciò consentirà ai percorsi di inserire nuovi log hiking nel database *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. Sostituisci il contenuto di `routes/index.js` con quanto riportato di seguito:
```
/*
* GET home page.
*/
exports.index = function(req, res){
res.render('index', { title: 'Express' });
};
```
1. Aggiungi il seguente modello jade a `views/hike.jade` per fornire l'interfaccia utente per l'aggiunta di log hiking.
```
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. Implementa le modifiche con il comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-rds$ eb deploy
```
## Eliminazione
Se hai finito di lavorare con Elastic Beanstalk, puoi terminare l'ambiente.
Utilizza il comando **eb terminate** per terminare l'ambiente e tutte le risorse che contiene.
```
~/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.
...
```
# 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:
+ **EC2 istanza**: una macchina virtuale Amazon Elastic Compute Cloud (Amazon EC2) configurata per eseguire 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 dell'istanza**: un gruppo EC2 di sicurezza Amazon configurato per consentire il traffico in entrata sulla porta 80. Questa risorsa consente al traffico HTTP proveniente dal sistema di bilanciamento del carico di raggiungere l' EC2 istanza su cui è in esecuzione la tua 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 Load Balancer: un gruppo** EC2 di sicurezza Amazon configurato per consentire 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\$1C** 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 delle EC2 istanze 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.
![\[CloudWatch dashboard showing CurrItems metric for an ElastiCache node over time.\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/elasticache-express.png)
**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.
# Distribuzione di un'applicazione Node.js con DynamoDB in Elastic Beanstalk
Questo tutorial e la relativa applicazione di esempio [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) illustrano il processo di distribuzione di un'applicazione Node.js che utilizza l' AWS SDK for JavaScript in Node.js per interagire con il servizio Amazon DynamoDB. Creerai una tabella DynamoDB che si trova in un database disaccoppiato, o esterno, dall'ambiente. AWS Elastic Beanstalk Configurerai anche l'applicazione per utilizzare un database disaccoppiato. In un ambiente di produzione, è consigliabile utilizzare un database disaccoppiato dall'ambiente Elastic Beanstalk in modo che sia indipendente dal ciclo di vita dell'ambiente. Questa procedura consente anche di eseguire [implementazioni blu/verde](using-features.CNAMESwap.md).
L'applicazione di esempio illustra quanto riportato di seguito:
+ Una tabella DynamoDB che archivia i dati di testo forniti dall'utente.
+ I [file di configurazione](ebextensions.md) per creare la tabella.
+ Un argomento su Amazon Simple Notification Service.
+ Utilizzo di un [file package.json](nodejs-platform-dependencies.md#nodejs-platform-packagejson) per installare i pacchetti durante l'implementazione.
**Topics**
+ [Prerequisiti](#nodejs-dynamodb-tutorial-prereqs)
+ [Creazione di un ambiente Elastic Beanstalk](#nodejs-dynamodb-tutorial-launch)
+ [Aggiungi le autorizzazioni alle istanze dell'ambiente](#nodejs-dynamodb-tutorial-role)
+ [Implementazione dell'applicazione di esempio](#nodejs-dynamodb-tutorial-deploy)
+ [Creazione di una tabella DynamoDB](#nodejs-dynamodb-tutorial-database)
+ [Aggiornamento dei file di configurazione dell'applicazione](#nodejs-dynamodb-tutorial-update)
+ [Configurazione dell'ambiente per l'elevata disponibilità](#nodejs-dynamodb-tutorial-configure)
+ [Pulizia](#nodejs-dynamodb-tutorial-cleanup)
+ [Fasi successive](#nodejs-dynamodb-tutorial-nextsteps)
## 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 a cui si fa 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-dynamo` per il pacchetto sorgente dell'applicazione. Crea la directory `nodejs-example-dynamo` per questo tutorial.
```
~$ mkdir nodejs-example-dynamo
```
**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-dynamo`.
```
~$ cd nodejs-example-dynamo
```
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-dynamo$ 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-dynamo$ eb create --sample nodejs-example-dynamo
```
Questo comando crea un ambiente con bilanciamento del carico con le impostazioni predefinite per la piattaforma Node.js e le risorse seguenti:
+ **EC2 istanza**: una macchina virtuale Amazon Elastic Compute Cloud (Amazon EC2) configurata per eseguire 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 dell'istanza**: un gruppo EC2 di sicurezza Amazon configurato per consentire il traffico in entrata sulla porta 80. Questa risorsa consente al traffico HTTP proveniente dal sistema di bilanciamento del carico di raggiungere l' EC2 istanza su cui è in esecuzione la tua 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 Load Balancer: un gruppo** EC2 di sicurezza Amazon configurato per consentire 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-dynamo$ 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.
## Aggiungi le autorizzazioni alle istanze dell'ambiente
L'applicazione viene eseguita su una o più EC2 istanze con un sistema di bilanciamento del carico, che serve le richieste HTTP da Internet. Quando riceve una richiesta che richiede l'utilizzo di AWS servizi, l'applicazione utilizza le autorizzazioni dell'istanza su cui viene eseguita per accedere a tali servizi.
L'applicazione di esempio utilizza le autorizzazioni dell'istanza per scrivere dati su una tabella DynamoDB e per inviare notifiche a un argomento di Amazon SNS con l'SDK for in Node.js. JavaScript Aggiungi le seguenti policy gestite al [profilo di istanza](concepts-roles-instance.md) predefinito per concedere alle EC2 istanze del tuo ambiente l'autorizzazione ad accedere a DynamoDB e Amazon SNS:
+ **AmazonDynamoDBFullAccesso**
+ **SNSFullAccesso Amazon**
**Per aggiungere policy al profilo dell'istanza di default**
1. Aprire la pagina [Roles (Ruoli)](https://console.aws.amazon.com/iam/home#roles) nella console IAM.
1. Scegli **aws-elasticbeanstalk-ec2 ruoli**.
1. Nella scheda **Autorizzazioni**, scegli **Collega policy**.
1. Seleziona la policy gestita per i servizi aggiuntivi utilizzati dall'applicazione. Per questo tutorial, seleziona `AmazonSNSFullAccess` e `AmazonDynamoDBFullAccess`.
1. Scegli **Collega policy**.
Per ulteriori informazioni sulla gestione dei profili delle istanze, consulta [Gestione dei profili dell'istanza Elastic Beanstalk](iam-instanceprofile.md).
## Implementazione dell'applicazione di esempio
[Ora il tuo ambiente è pronto per la distribuzione e l'esecuzione dell'applicazione di esempio per questo tutorial: nodejs-example-dynamo .zip.](samples/nodejs-example-dynamo.zip)
**Implementazione ed esecuzione dell'applicazione di esempio del tutorial**
1. Modifica la directory di lavoro corrente nella directory dell'applicazione `nodejs-example-dynamo`.
```
~$ cd nodejs-example-dynamo
```
1. Scaricate ed estraete il contenuto del pacchetto sorgente dell'applicazione di esempio [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) nella directory dell'applicazione. `nodejs-example-dynamo`
1. Implementa l'applicazione di esempio nell'ambiente Elastic Beanstalk con il comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-dynamo$ eb deploy
```
**Nota**
Per impostazione predefinita, il `eb deploy` comando crea un file ZIP della cartella del progetto. È possibile anche configurare la CLI EB per distribuire un artefatto del processo di build anziché creare un file ZIP della cartella di progetto. Per ulteriori informazioni, consulta [Distribuzione di artifact invece della cartella del progetto](eb-cli3-configuration.md#eb-cli3-artifact).
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-dynamo$ eb open
```
Il sito raccoglie le informazioni di contatto degli utenti e utilizza una tabella DynamoDB per archiviare i dati. Per aggiungere una voce, seleziona **Sign up today (Registrati oggi stesso)**, inserisci un nome e un indirizzo di posta elettronica, quindi scegli **Sign up\$1 (Registrati)** L'applicazione Web scrive i contenuti del modulo sulla tabella e attiva una notifica Amazon SNS via e-mail.
![\[Startup landing page with teaser message and sign-up button for upcoming product launch.\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/nodejs-dynamodb-tutorial-app.png)
In questo momento, l'argomento Amazon SNS è configurato con un'e-mail segnaposto per le notifiche. Aggiornerai la configurazione a breve, ma nel frattempo è possibile verificare la tabella DynamoDB e l'argomento Amazon SNS nella console di gestione Console di gestione AWS.
**Per visualizzare la tabella**
1. Apri la [pagina delle tabelle](https://console.aws.amazon.com/dynamodb/home?#tables:) nella console DynamoDB.
1. Trova la tabella creata dall'applicazione. Il nome inizia con **awseb e contiene**. **StartupSignupsTable**
1. Seleziona la tabella, quindi **Items** (Voci) e **Start search** (Avvia ricerca) per visualizzare tutti gli elementi della tabella.
La tabella contiene una voce per ogni indirizzo e-mail inviato sul sito dell'iscrizione. Oltre a scrivere sulla tabella, l'applicazione invia un messaggio a un argomento Amazon SNS che dispone di due abbonamenti, uno per le notifiche e-mail per l'utente e un altro per una coda Amazon Simple Queue Service da cui un'applicazione worker è in grado di leggere per elaborare le richieste e inviare e-mail ai clienti interessati.
**Per visualizzare l'argomento**
1. Apri la [pagina degli argomenti](https://console.aws.amazon.com/sns/v2/home?#/topics) nella console Amazon SNS.
1. Trova l'argomento creato dall'applicazione. Il nome inizia con **awseb** e contiene. **NewSignupTopic**
1. Scegli l'argomento per visualizzare le sottoscrizioni.
L'applicazione (`[app.js](https://github.com/awslabs/eb-node-express-sample/blob/master/app.js)`) definisce due itinerari. Il percorso principale (`/`) restituisce una pagina Web renderizzata da un modello Embedded JavaScript (EJS) con un modulo che l'utente compila per registrare il proprio nome e indirizzo e-mail. Con l'inserimento del modulo viene inviata una richiesta POST con i dati al percorso `/signup` che scrive una voce nella tabella DynamoDB e pubblica un messaggio nell'argomento Amazon SNS per notificare il proprietario dell'iscrizione.
L'applicazione di esempio include i [file di configurazione](ebextensions.md) che creano la tabella DynamoDB, l'argomento Amazon SNS e la coda Amazon SQS utilizzati dall'applicazione. Ciò consente di creare un nuovo ambiente e di verificare la funzionalità immediatamente, ma ha lo svantaggio di vincolare la tabella DynamoDB all'ambiente. Per un ambiente di produzione, è necessario creare la tabella DynamoDB al di fuori dell'ambiente per evitare di perderla quando termini l'ambiente o ne aggiorni la configurazione.
## Creazione di una tabella DynamoDB
Per utilizzare una tabella DynamoDB esterna con un'applicazione in esecuzione in Elastic Beanstalk, crea innanzitutto una tabella in DynamoDB. Quando crei una tabella esternamente a Elastic Beanstalk, essa sarà indipendente da Elastic Beanstalk e dagli ambienti Elastic Beanstalk e non verrà arrestata da Elastic Beanstalk.
Creare una tabella con le impostazioni seguenti:
+ **Table name** (Nome tabella) – **nodejs-tutorial**
+ **Primary key** (Chiave primaria) – **email**
+ Tipo chiave principale: **String (Stringa)**
**Per creare una tabella DynamoDB**
1. Apri la [pagina delle tabelle](https://console.aws.amazon.com/dynamodb/home?#tables:) nella console di gestione DynamoDB.
1. Scegliere **Create table (Crea tabella)**.
1. Digita un **Table name (Nome tabella)** e la **Primary key (Chiave primaria)**.
1. Scegli il tipo di chiave primaria.
1. Scegli **Create** (Crea).
## Aggiornamento dei file di configurazione dell'applicazione
Aggiorna i [file di configurazione](ebextensions.md) nella sorgente dell'applicazione per utilizzare la tabella **nodejs-tutorial** invece di crearne una nuova.
**Aggiornamento dell'applicazione di esempio per l'uso negli ambienti di produzione**
1. Modifica la directory di lavoro corrente nella directory dell'applicazione `nodejs-example-dynamo`.
```
~$ cd nodejs-example-dynamo
```
1. Apri `.ebextensions/options.config` e modifica i valori delle impostazioni seguenti:
+ **NewSignupEmail**— Il tuo indirizzo email.
+ **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"
```
Ciò vale per le seguenti configurazioni per l'applicazione:
+ L'indirizzo e-mail che l'argomento Amazon SNS impiega per le notifiche è impostato sul tuo indirizzo o su quello che inserisci nel file `options.config`.
+ La tabella **nodejs-tutorial** verrà utilizzata al posto di quella creata da `.ebextensions/create-dynamodb-table.config`.
1. Remove `.ebextensions/create-dynamodb-table.config`.
```
~/nodejs-tutorial$ rm .ebextensions/create-dynamodb-table.config
```
La prossima volta che distribuisci l'applicazione, la tabella creata da questo file di configurazione verrà eliminata.
1. Implementa l'applicazione aggiornata nell'ambiente Elastic Beanstalk con il comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-dynamo$ eb deploy
```
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-dynamo$ eb open
```
Durante la distribuzione, Elastic Beanstalk aggiorna la configurazione dell'argomento Amazon SNS ed elimina la tabella DynamoDB creata quando hai distribuito la prima versione dell'applicazione.
Ora, quando termini l'ambiente, la tabella **nodejs-tutorial** non sarà eliminata. In questo modo è possibile eseguire le implementazioni blu/verdi, modificare i file di configurazione oppure arrestare il sito Web senza il rischio di perdite di dati.
Apri il sito in un browser e verifica che il modulo funzioni come previsto. Crea alcune voci, quindi controlla la console DynamoDB per verificare la tabella.
**Per visualizzare la tabella**
1. Apri la [pagina delle tabelle](https://console.aws.amazon.com/dynamodb/home?#tables:) nella console DynamoDB.
1. Trova la tabella **nodejs-tutorial**.
1. Seleziona la tabella, quindi **Items** (Voci) e **Start search** (Avvia ricerca) per visualizzare tutti gli elementi della tabella.
Puoi anche notare che Elastic Beanstalk ha eliminato la tabella creata in precedenza.
## Configurazione dell'ambiente per l'elevata disponibilità
Infine, configura il gruppo Auto Scaling dell'ambiente con un conteggio delle istanze minime più elevato. Esegui almeno due istanze in qualsiasi momento per evitare che i server Web nell'ambiente rappresentino una singola possibilità di errore e per consentire di distribuire le modifiche senza interrompere il funzionamento del servizio.
**Configurazione del gruppo Auto Scaling dell'ambiente per elevata disponibilità**
1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS
1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.
1. Nel riquadro di navigazione, selezionare **Configuration (Configurazione)**.
1. Nella categoria di configurazione **Capacity (Capacità)**, scegliere **Edit (Modifica)**.
1. Nella sezione **Auto Scaling Group (Gruppo Auto Scaling)**, impostare **Min instances (Istanze min)** su **2**.
1. Per salvare le modifiche scegli **Apply** (Applica) nella parte inferiore della pagina.
## Pulizia
Dopo aver finito di utilizzare il codice demo, puoi chiudere l'ambiente. [Elastic Beanstalk elimina tutte le risorse AWS correlate, [come istanze EC2 Amazon](using-features.managing.ec2.md), [istanze di database, sistemi di bilanciamento del carico, gruppi](using-features.managing.db.md) di sicurezza e [allarmi](using-features.managing.elb.md).](using-features.alarms.md#using-features.alarms.title)
La rimozione delle risorse non elimina l'applicazione Elastic Beanstalk, quindi puoi creare nuovi ambienti per la tua applicazione in qualsiasi momento.
**Per terminare l'ambiente Elastic Beanstalk dalla console**
1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS
1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.
1. Seleziona **Actions** (Operazioni), quindi **Terminate environment** (Termina ambiente).
1. Utilizza la finestra di dialogo su schermo per confermare la terminazione dell'ambiente.
Puoi anche eliminare le tabelle DynamoDB esterne che hai creato.
**Per eliminare una tabella DynamoDB**
1. Apri la [pagina delle tabelle](https://console.aws.amazon.com/dynamodb/home?#tables:) nella console DynamoDB.
1. Seleziona una tabella.
1. Seleziona **Actions (Operazioni)**, quindi **Delete table (Elimina tabella)**.
1. Scegli **Elimina**.
## Fasi successive
L'applicazione di esempio utilizza i file di configurazione per configurare le impostazioni del software e creare AWS risorse come parte dell'ambiente. Per ulteriori informazioni sui file di configurazione e sul loro uso, consulta [Personalizzazione avanzata dell'ambiente con i file di configurazione (`.ebextensions`)](ebextensions.md).
L'applicazione di esempio per questo tutorial usa il framework Web Express per Node.js. Per ulteriori informazioni su Express, consulta la documentazione ufficiale alla pagina [expressjs.com](https://expressjs.com).
Infine, se intendi utilizzare l'applicazione in un ambiente di produzione, devi [configurare un nome di dominio personalizzato](customdomains.md) per l'ambiente e [abilitare HTTPS](configuring-https.md) per le connessioni sicure.
# Aggiungere un'istanza Amazon RDS DB all'ambiente Node.js Elastic Beanstalk
Questo argomento fornisce istruzioni per creare un Amazon RDS utilizzando la console Elastic Beanstalk. Puoi utilizzare un'istanza database Amazon Relational Database Service (Amazon RDS) per archiviare i dati raccolti e modificati dall'applicazione. Il database può essere accoppiato all'ambiente e gestito da Elastic Beanstalk oppure può essere creato e gestito esternamente da un altro servizio. In queste istruzioni il database è accoppiato all'ambiente e gestito da Elastic Beanstalk. Per ulteriori informazioni sull'integrazione di un Amazon RDS con Elastic Beanstalk, consulta [Aggiunta di un database all'ambiente Elastic Beanstalk](using-features.managing.db.md).
**Topics**
+ [Aggiunta di un'istanza database all'ambiente](#nodejs-rds-create)
+ [Download di un driver](#nodejs-rds-drivers)
+ [Connessione a un database](#nodejs-rds-connect)
## Aggiunta di un'istanza database all'ambiente
**Per aggiungere un'istanza database al tuo ambiente**
1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS
1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.
1. Nel pannello di navigazione, selezionare **Configuration** (Configurazione).
1. Nella categoria di configurazione del **Database**, scegliere **Edit (Modifica)**.
1. Scegliere un motore di database e immettere un nome utente e una password.
1. Per salvare le modifiche scegli **Apply** (Applica) nella parte inferiore della pagina.
L'aggiunta di un'istanza database richiede circa 10 minuti. Quando l'aggiornamento dell'ambiente è completo, il nome host dell'istanza database e altre informazioni di connessione sono disponibili per la tua applicazione tramite le seguenti proprietà dell'ambiente:
| Nome proprietà | Descrizione | Valore proprietà |
| --- | --- | --- |
| `RDS_HOSTNAME` | Il nome host dell'istanza DB. | Nella scheda **Connectivity & security** (Connettività e sicurezza) della console Amazon RDS: **Endpoint**. |
| `RDS_PORT` | La porta su cui l'istanza database accetta le connessioni. Il valore predefinito varia tra i motori di database. | Nella scheda **Connectivity & security (Connettività e sicurezza)** della console Amazon RDS: **Port (Porta)**. |
| `RDS_DB_NAME` | Il nome del database, **ebdb**. | Nella scheda **Configuration (Configurazione)** della console Amazon RDS: **DB Name (Nome DB)**. |
| `RDS_USERNAME` | Il nome utente configurato per il database. | Nella scheda **Configuration (Configurazione)** della console Amazon RDS: **Master username (Nome utente master)**. |
| `RDS_PASSWORD` | La password configurata per il database. | Non disponibile per riferimento nella console Amazon RDS. |
Per ulteriori informazioni sulla configurazione di un'istanza di database accoppiata a un ambiente Elastic Beanstalk, consulta [Aggiunta di un database all'ambiente Elastic Beanstalk](using-features.managing.db.md).
## Download di un driver
Aggiungi il driver di database al file [`package.json` del progetto](nodejs-platform-dependencies.md#nodejs-platform-packagejson) in `dependencies`.
**Example `package.json`: Express con 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"
}
}
```
**Pacchetti di driver comuni per 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)
## Connessione a un database
Elastic Beanstalk fornisce informazioni di connessione per le istanze database collegate nelle proprietà dell'ambiente. Utilizza `process.env.VARIABLE` per leggere le proprietà e configurare una connessione di database.
**Example app.js: connessione al database 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();
```
[Per ulteriori informazioni sulla creazione di una stringa di connessione utilizzando node-mysql, vedi npmjs. org/package/mysql](https://npmjs.org/package/mysql).
# Strumenti e risorse Node.js
Di seguito sono elencate alcune risorse che ti consentono di ottenere ulteriori informazioni relative allo sviluppo di applicazioni Node.js:
****
| Risorsa | Description |
| --- | --- |
| [GitHub](https://github.com/aws/aws-sdk-js) | Installa l' AWS SDK per Node.js utilizzando GitHub. |
| [AWS SDK per Node.js (anteprima per sviluppatori)](https://aws.amazon.com/sdkfornodejs/) | Punto di riferimento per il codice di esempio, la documentazione, gli strumenti e risorse aggiuntive. |