Implementación de una aplicación Express en Elastic Beanstalk - AWS Elastic Beanstalk
Requisitos previosCree un entorno de Elastic BeanstalkActualizar la aplicación para que use ExpressActualice la aplicación para que use Amazon RDS.Eliminar recursos

Implementación de una aplicación Express en Elastic Beanstalk

En esta sección, se describe cómo se implementa una aplicación de ejemplo en Elastic Beanstalk con la interfaz de línea de comando de Elastic Beanstalk (CLI de EB), y cómo se la actualiza después para utilizar el marco de Express.

Requisitos previos

Este tutorial tiene siguientes los requisitos previos:

  • Los tiempos de ejecución de Node.js

  • El software de gestión de paquetes de Node.js predeterminado, npm

  • El generador de línea de comandos Express

  • La interfaz de línea de comando de Elastic Beanstalk (CLI de EB)

Para obtener más detalles acerca de la instalación de los primeros tres componentes y la configuración de su entorno de desarrollo local, consulte Configuración del entorno de desarrollo de Node.js. En este tutorial, no es necesario que instale el AWS SDK para Node.js, que también se menciona en el tema de referencia.

Para obtener detalles sobre la instalación y configuración de la CLI de EB, consulte Instalación de la CLI de EB y Configuración de la CLI de EB.

Cree un entorno de Elastic Beanstalk

Su directorio de aplicaciones

Este tutorial usa un directorio llamado nodejs-example-express-rds para el paquete de origen de la aplicación. Cree el directorio nodejs-example-express-rds para este tutorial.

~$ mkdir nodejs-example-express-rds
nota

Cada tutorial de este capítulo usa su propio directorio para el paquete de origen de la aplicación. El nombre del directorio coincide con el nombre de la aplicación de ejemplo utilizada en el tutorial.

Cambie su directorio de trabajo actual a nodejs-example-express-rds.

~$ cd nodejs-example-express-rds

Ahora configuremos un entorno de Elastic Beanstalk que ejecute la plataforma Node.js y la aplicación de ejemplo. Se usará la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB)

Para configurar un repositorio en la CLI de EB para la aplicación y crear un entorno de Elastic Beanstalk que ejecute la plataforma Node.js

  1. Cree un repositorio con el comando eb init.

    ~/nodejs-example-express-rds$ eb init --platform node.js --region <region>

    Este comando crea un archivo de configuración en una carpeta llamada .elasticbeanstalk que especifica los ajustes para crear los entornos de la aplicación y crea una aplicación de Elastic Beanstalk con el nombre de la carpeta actual.

  2. Cree un entorno que ejecute una aplicación de ejemplo con el comando eb create.

    ~/nodejs-example-express-rds$ eb create --sample nodejs-example-express-rds

    Este comando crea un entorno con balanceador de carga utilizando la configuración predeterminada de la plataforma de Node.js y los siguientes recursos:

    • Instancia de EC2: una máquina virtual de Amazon Elastic Compute Cloud (Amazon EC2) configurada para ejecutar aplicaciones web en la plataforma que elija.

      Cada plataforma ejecuta un conjunto específico de software, archivos de configuración y scripts compatibles con una determinada versión de lenguaje, marco de trabajo y contenedor web (o una combinación de estos). La mayoría de las plataformas utilizan Apache o nginx como un proxy inverso que se sitúa delante de la aplicación web, reenvía las solicitudes a esta, administra los recursos estáticos y genera registros de acceso y errores.

    • Instance security group (Grupo de seguridad de la instancia): grupo de seguridad de Amazon EC2 configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP procedente del balanceador de carga llegue a la instancia EC2 en la que se ejecuta la aplicación web. De forma predeterminada, el tráfico no está permitido en otros puertos.

    • Balanceador de carga: balanceador de carga de Elastic Load Balancing configurado para distribuir solicitudes a las instancias que se ejecutan en la aplicación. Los balanceadores de carga también permiten que las instancias no estén expuestas directamente a Internet.

    • Grupo de seguridad del balanceador de carga: grupo de seguridad de Amazon EC2 configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP procedente de Internet llegue al balanceador de carga. De forma predeterminada, el tráfico no está permitido en otros puertos.

    • Grupo de Auto Scaling: grupo de Auto Scaling configurado para reemplazar una instancia si termina o deja de estar disponible.

    • Bucket de Amazon S3: ubicación de almacenamiento para el código fuente, los registros y otros artefactos que se crean al utilizar Elastic Beanstalk.

    • Alarmas de Amazon CloudWatch: dos alarmas de CloudWatch que supervisan la carga de las instancias del entorno y que se activan si la carga es demasiado alta o demasiado baja. Cuando se activa una alarma, en respuesta, el grupo de Auto Scaling aumenta o reduce los recursos.

    • Pila de AWS CloudFormation. Elastic Beanstalk utiliza AWS CloudFormation para lanzar los recursos en su entorno y propagar los cambios de configuración. Los recursos se definen en una plantilla que puede verse en la consola de AWS CloudFormation.

    • Nombre de dominio: nombre de dominio que direcciona el tráfico a la aplicación web con el formato subdominio.región.elasticbeanstalk.com.

  3. Cuando se complete la creación del entorno, utilice el comando eb open para abrir la URL del entorno en el navegador predeterminado.

    ~/nodejs-example-express-rds$ eb open

Ahora ha creado un entorno de Elastic Beanstalk para Node.js con una aplicación de ejemplo. Puede actualizarlo con su propia aplicación. Luego, actualizamos la aplicación de ejemplo para que use el marco de Express.

Actualizar la aplicación para que use Express

Una vez que haya creado el entorno con una aplicación de ejemplo, puede actualizarlo con su propia aplicación. En este procedimiento, ejecutamos primero los comandosexpress y npm install para configurar el marco de Express en el directorio de la aplicación. Luego use la CLI de EB para actualizar su entorno Elastic Beanstalk con la aplicación actualizada.

Si desea actualizar la aplicación para que use Express

  1. Ejecute el comando express. Esto genera package.json, app.js y unos directorios.

    ~/nodejs-example-express-rds$ express

    Cuando se le pregunte, escriba y si desea continuar.

    nota

    Si el comando express no funciona, es posible que no haya instalado el generador de línea de comandos Express tal y como se describe en la sección Requisitos previos anterior. O bien, puede que sea necesario configurar la ruta del directorio de su máquina local para ejecutar el comando express. Consulte la sección Requisitos previos para conocer los pasos detallados sobre la configuración del entorno de desarrollo, de modo que pueda continuar con este tutorial.

  2. Configure las dependencias locales.

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

  3. (Opcional) Compruebe que el servidor de aplicaciones web se inicie.

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

    Debería ver un resultado similar a este:

    > nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www

    El servidor se ejecuta en el puerto 3000 de forma predeterminada. Para probarlo, ejecute curl http://localhost:3000 en otro terminal o abra un navegador en el equipo local e ingrese el http://localhost:3000 de la dirección URL.

    Presione Ctrl+C para detener el servidor.

  4. Implemente los cambios en su entorno Elastic Beanstalk con el comando eb deploy.

    ~/nodejs-example-express-rds$ eb deploy

  5. Una vez que el entorno esté listo, actualice la dirección URL para verificar que ha funcionado. Debería aparecer una página web que diga Welcome to Express.

A continuación, vamos a actualizar la aplicación de Express para atender archivos estáticos y agregar una nueva página.

Para configurar archivos estáticos y agregar una nueva página a la aplicación de Express

  1. Agregue un segundo archivo de configuración en la carpeta .ebextensions con el contenido siguiente:

    nodejs-example-express-rds/.ebextensions/staticfiles.config

    option_settings:
    aws:elasticbeanstalk:environment:proxy:staticfiles:
        /stylesheets: public/stylesheets

    Esta opción configura el servidor proxy que proporcione los archivos en la carpeta public de la ruta /public de la aplicación. Si los archivos se sirven de forma estática desde el servidor proxy, se reduce la carga en la aplicación. Para obtener más información, consulte Archivos estáticos mencionada previamente en este capítulo.

  2. (Opcional) Para confirmar que las asignaciones estáticas están configuradas correctamente, comente la configuración de asignación estática en nodejs-example-express-rds/app.js. Esto elimina la asignación de la aplicación de nodos.

    //  app.use(express.static(path.join(__dirname, 'public')));

    Las asignaciones de archivos estáticas del archivo staticfiles.config del paso anterior deberían seguir cargando la hoja de estilos correctamente, incluso después de comentar esta línea. Para comprobar que las asignaciones de archivos estáticas se cargan mediante la configuración de archivos estáticos del proxy, en lugar de mediante la aplicación exprés, elimine los valores siguientesoption_settings:. Una vez que se haya eliminado de la configuración del archivo estático y de la aplicación de nodo, la hoja de estilos no se cargará.

    Recuerde restablecer el contenido de nodejs-example-express-rds/app.js y de staticfiles.config cuando haya terminado las pruebas.

  3. Add nodejs-example-express-rds/routes/hike.js. Escriba lo siguiente:

    exports.index = function(req, res) {
 res.render('hike', {title: 'My Hiking Log'});
};

exports.add_hike = function(req, res) {
};

  4. Actualice nodejs-example-express-rds/app.js para incluir tres nuevas líneas.

    En primer lugar, inserte la siguiente línea para agregar un objeto require para esta ruta:

    var hike = require('./routes/hike');

    El archivo debe ser similar al siguiente fragmento:

    var express = require('express');
var path = require('path');
var hike = require('./routes/hike');

    A continuación, agregue las dos líneas siguientes a nodejs-example-express-rds/app.js detrás de var app = express();.

    app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);

    El archivo debe ser similar al siguiente fragmento:

    var app = express();
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);

  5. Copie nodejs-example-express-rds/views/index.jade en nodejs-example-express-rds/views/hike.jade. 

    ~/nodejs-example-express-rds$ cp views/index.jade views/hike.jade

  6. Implemente los cambios con el comando eb deploy.

    ~/nodejs-example-express-rds$ eb deploy

  7. Su entorno se actualizará al cabo de unos minutos. Cuando el entorno esté listo, asegúrese de que funciona actualizando el navegador y agregando hikes al final de la URL (por ejemplo, http://node-express-env-syypntcz2q.elasticbeanstalk.com/hikes).

    Debería ver una página web con el título My Hiking Log.

Ya ha creado una aplicación web que utiliza el marco Express. En la siguiente sección, modificaremos la aplicación para utilizar un Amazon Relational Database Service (RDS) para almacenar un registro de hiking.

Actualice la aplicación para que use Amazon RDS.

En el siguiente paso, actualizamos la aplicación para usar Amazon RDS para MySQL.

Para actualizar la aplicación para que use RDS para MySQL

  1. Para crear una base de datos RDS para MySQL acoplada a su entorno de Elastic Beanstalk, siga las instrucciones del tema Agregar una base de datos que se incluye más adelante en este capítulo. Añadir una instancia de base de datos demora aproximadamente 10 minutos.

  2. Actualice la sección de dependencias en package.json con el siguiente contenido: 

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

  3. Ejecute npm install.

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

  4. Actualice app.js para conectarse a la base de datos, crear una tabla e insertar un único registro de hiking predeterminado. Cada vez que se implemente esta aplicación, eliminará la tabla de hiking anterior y la volverá a crear.

    /**
 * 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

  5. Agregue el siguiente contenido a routes/hike.js. Esto permitirá a las rutas insertar nuevos registros de hiking en la base de datos de 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');
      }
   });
};

  6. Reemplace todo el contenido de routes/index.js por lo siguiente:

    /*
 * GET home page.
 */

exports.index = function(req, res){
  res.render('index', { title: 'Express' });
};

  7. Añada la siguiente plantilla de jade a views/hike.jade para proporcionar la interfaz de usuario para añadir registros de 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}

  8. Implemente los cambios con el comando eb deploy.

    ~/nodejs-example-express-rds$ eb deploy

Eliminar recursos

Si ha terminado de trabajar con Elastic Beanstalk, puede terminar su entorno.

Utilice el comando eb terminate para terminar el entorno y todos los recursos que 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.
...