Prerequisiti Creazione di un ambiente Elastic Beanstalk Aggiornamento dell'applicazione per usare Express Aggiorna l'applicazione per utilizzare Amazon RDS Eliminazione

Distribuzione di un'applicazione Express in Elastic Beanstalk

Questa sezione illustra la distribuzione di un'applicazione di esempio su Elastic Beanstalk utilizzando l'Elastic Beanstalk Command CLI Line Interface (EB) e quindi l'aggiornamento dell'applicazione per utilizzare il framework Express.

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
L'interfaccia a riga di comando (EB) di Elastic Beanstalk CLI

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 questo tutorial, non è necessario installare il file AWS SDK for Node.js, anch'esso menzionato nell'argomento a cui si fa riferimento.

Per informazioni dettagliate sull'installazione e la configurazione dell'EBCLI, vedere Installa l'interfaccia a riga di comando EB e. Configurazione dell'interfaccia a riga di comando EB

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. Useremo l'interfaccia a riga di comando (EB) di Elastic Beanstalk. CLI

Per configurare un CLI repository EB per l'applicazione e creare un ambiente Elastic Beanstalk che esegue la piattaforma Node.js

Creazione di un repository con il comando eb init.
```
~/nodejs-example-express-rds$ eb init --platform node.js --region <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.
Crea un ambiente che esegue un'applicazione di esempio con il comando eb create.
```
~/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:
- EC2istanza: una macchina virtuale Amazon Elastic Compute Cloud (AmazonEC2) 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 che si trova davanti all'app Web, inoltra le richieste, fornisce risorse statiche e genera log di accesso 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 HTTP traffico proveniente dal sistema di bilanciamento del carico di raggiungere l'EC2istanza 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 consente al HTTP 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.
- AWS CloudFormation stack: Elastic AWS 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 AWS CloudFormation.
- Nome di dominio: un nome di dominio che indirizza alla tua app Web nel modulo subdomain.region.elasticbeanstalk.com.
  
  Nota
  Per aumentare la sicurezza delle tue applicazioni Elastic Beanstalk, il dominio elasticbeanstalk.com è registrato nella Public Suffix List (). PSL Per una maggiore sicurezza, ti consigliamo di utilizzare i cookie con un prefisso __Host- se hai bisogno di impostare cookie sensibili nel nome di dominio predefinito per le tue applicazioni Elastic Beanstalk. Questa pratica ti aiuterà a difendere il tuo dominio dai tentativi di falsificazione delle richieste tra siti (). CSRF Per ulteriori informazioni, consulta la pagina Impostazione cookie nella pagina Mozilla Developer Network.
Al termine della creazione dell'ambiente, utilizzate il eb opencomando per aprire l'ambiente URL 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 utilizziamo l'EB CLI per aggiornare il tuo ambiente Elastic Beanstalk con l'applicazione aggiornata.

Per aggiornare l'applicazione per usare Express

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.

Configura le dipendenze locali.


~/nodejs-example-express-rds$ npm install

(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, eseguilo curl http://localhost:3000 su un altro terminale o apri un browser sul computer locale e inserisci l'indirizzo. URL http://localhost:3000

Premi Ctrl+C per arrestare il server.
Implementa le modifiche apportate all'ambiente Elastic Beanstalk con il comando eb deploy.
```
~/nodejs-example-express-rds$ eb deploy
```
Una volta che l'ambiente è verde e pronto, aggiornalo URL per verificare che funzioni. 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

Aggiungi un secondo file di configurazione nella cartella .ebextensions 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 descritta precedentemente in questo capitolo.
(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.

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) {
};

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);
```
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
```
Implementa le modifiche con il comando eb deploy.
```
~/nodejs-example-express-rds$ eb deploy
```
Il tuo ambiente sarà aggiornato dopo qualche minuto. Dopo che l'ambiente è verde e pronto, verifica che funzioni aggiornando il browser e aggiungendolo alla hikes fine di 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 registro escursionistico.

Aggiorna l'applicazione per utilizzare Amazon RDS

In questo passaggio successivo aggiorniamo l'applicazione per utilizzare Amazon RDS for MySQL.

Per aggiornare l'applicazione da utilizzare RDS per My SQL

Per creare un SQL database RDS for My accoppiato al tuo ambiente Elastic Beanstalk, segui le istruzioni nell'argomento Aggiungere un database incluso più avanti in questo capitolo. L'aggiunta di un'istanza del database richiede circa 10 minuti.

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"
  }

Esegui npm install.


~/nodejs-example-express-rds$ npm install

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

Aggiungi il seguente contenuto a routes/hike.js. Ciò consentirà ai percorsi di inserire nuovi registri escursionistici 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');
      }
   });
};

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' });
};

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}

Implementa le modifiche con il comando eb deploy.
```
~/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.
...

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Esempi di applicazioni e tutorial

Tutorial – Express con clustering