Cómo instalar Sails.js Framework con Nginx en Ubuntu 22.04

Sails.js es un framework MVC JavaScript de pila completa para Node.js. Se utiliza para desarrollar aplicaciones web en tiempo real. Está inspirado en Ruby on Rails, pero con soporte para APIs basadas en datos y una arquitectura escalable y orientada a servicios. Utiliza un potente mapeo objeto-relacional (ORM) llamado Waterline que permite utilizarlo con bases de datos como MySQL, PostgreSQL, MongoDB, Redis, etc.

En este tutorial, aprenderás a instalar el framework Sails.js para crear una aplicación de prueba y desplegarla utilizando el servidor Nginx junto con Let’s Encrypt SSL en un servidor Ubuntu 22.04.

Requisitos previos

  • Un servidor con Ubuntu 22.04.

  • Un usuario no root con privilegios sudo.

  • El Firewall sin complicaciones (UFW) está activado y en funcionamiento.

  • Un nombre de dominio totalmente cualificado que apunte al servidor. Para nuestro tutorial, utilizaremos el dominio sails.example.com.

  • Todo está actualizado.

    $ sudo apt update && sudo apt upgrade
    

Paso 1 – Configurar el cortafuegos

El primer paso antes de instalar cualquier paquete es configurar el cortafuegos para que permita las conexiones HTTP y HTTPS.

Comprueba el estado del cortafuegos.

$ sudo ufw status

Deberías ver algo como lo siguiente

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Permitir puertos HTTP y HTTPs.

$ sudo ufw allow http
$ sudo ufw allow https

Vuelve a comprobar el estado para confirmarlo.

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Paso 2 – Instalar el gestor de versiones de Node (NVM)

Instalaremos Node utilizando la aplicación Node Version Manager (nvm). Puedes utilizar NVM para instalar varias versiones de Node y cambiar entre ellas con facilidad. Ejecuta el siguiente comando para descargar e instalar NVM.

Comprueba la última versión de NVM en la página de versiones de Github. En el momento de escribir este tutorial, la v0.39.1 es la última versión disponible.

$ NVMVERSION=0.39.1
$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/$NVMVERSION/install.sh | bash

Actualiza el terminal.

$ source ~/.bashrc

Comprueba que NVM está instalado.

$ command -v nvm

Deberías ver la siguiente salida si la instalación se realiza correctamente.

nvm

Paso 3 – Instalar Node.js

Vamos a instalar la última versión de la versión LTS (Long term support) de Node.js. Ejecuta el siguiente comando para hacerlo.

$ nvm install --lts

Comprueba que Node.js está instalado.

$ node --version
v16.17.0

Paso 4 – Instalar Sails.js

Ahora que Node.js está instalado, es el momento de instalar el framework Sails.js. Ejecuta el siguiente comando para instalarlo globalmente.

$ npm -g install sails

Comprueba que el framework Sails.js está instalado.

$ sails --version
1.5.3

Puedes comprobar otros comandos disponibles con la aplicación de línea de comandos sails utilizando la bandera --help.

$ sails --help

Recibirás la siguiente salida.

Usage: sails [command]

  Options:

    -v, --version  output the version number
    -h, --help     output usage information

  Commands:

    version
    lift|l [options]
    new [options] [path_to_new_app]
    generate
    upgrade
    migrate
    console|c [options]
    www
    debug                            (for Node v5 and below)
    inspect                          (for Node v6 and above)
    run
    test
    lint
    deploy
    debug-console|dc
    help [command]

Paso 5 – Crear una aplicación de demostración

Ejecuta el siguiente comando para generar una aplicación de demostración.

$ sails new howtoforge-app

Obtendrás las dos opciones siguientes.

Choose a template for your new Sails app:
 1. Web App  ·  Extensible project with auth, login, & password recovery
 2. Empty    ·  An empty Sails app, yours to configure
 (type "?" for help, or <CTRL+C> to cancel)

Puedes escribir 1 para ir con una plantilla predefinida para una aplicación completa con autenticación, una página de inicio de sesión y una función de recuperación de contraseña. Si quieres empezar con una pizarra en blanco, elige la opción 2.

Nosotros optaremos por la opción 1. Tendrás que esperar unos minutos a que se complete el proceso.

? 1
 info: Installing dependencies...
Press CTRL+C to cancel.
(to skip this step in the future, use --fast)
 info: Created a new Sails app `howtoforge-app`!

Cambia al directorio de trabajo de la aplicación recién creada. El nombre del directorio es el mismo que el de tu aplicación.

$ cd howtoforge-app

Comprueba el listado de carpetas. La carpeta tendrá todos los archivos y paquetes esenciales instalados para que puedas empezar con la aplicación.

$ ls
total 944
drwxrwxr-x   9 navjot navjot   4096 Aug 23 07:14 .
drwxr-x---   8 navjot navjot   4096 Aug 23 07:13 ..
drwxrwxr-x   8 navjot navjot   4096 Aug 23 07:13 api
-rw-rw-r--   1 navjot navjot   1841 Aug 23 07:13 app.js
drwxrwxr-x   8 navjot navjot   4096 Aug 23 07:13 assets
drwxrwxr-x   4 navjot navjot   4096 Aug 23 07:13 config
-rw-rw-r--   1 navjot navjot   1046 Aug 23 07:13 .editorconfig
-rw-rw-r--   1 navjot navjot     44 Aug 23 07:13 .eslintignore
-rw-rw-r--   1 navjot navjot   4228 Aug 23 07:13 .eslintrc
-rw-rw-r--   1 navjot navjot   3531 Aug 23 07:13 .gitignore
-rw-rw-r--   1 navjot navjot    669 Aug 23 07:13 Gruntfile.js
-rw-rw-r--   1 navjot navjot    709 Aug 23 07:13 .htmlhintrc
-rw-rw-r--   1 navjot navjot   2162 Aug 23 07:13 .lesshintrc
drwxrwxr-x 510 navjot navjot  20480 Aug 23 07:14 node_modules
-rw-rw-r--   1 navjot navjot    369 Aug 23 07:13 .npmrc
-rw-rw-r--   1 navjot navjot   6151 Aug 23 07:13 package.json
-rw-rw-r--   1 navjot navjot 854958 Aug 23 07:14 package-lock.json
-rw-rw-r--   1 navjot navjot   1732 Aug 23 07:13 README.md
-rw-rw-r--   1 navjot navjot    123 Aug 23 07:13 .sailsrc
drwxrwxr-x   2 navjot navjot   4096 Aug 23 07:13 scripts
drwxrwxr-x   4 navjot navjot   4096 Aug 23 07:13 tasks
drwxrwxr-x   5 navjot navjot   4096 Aug 23 07:13 views

Ejecuta la aplicación Sails. El siguiente comando iniciará la aplicación en modo de desarrollo. Sails.js utiliza la herramienta Grunt para controlar la carpeta /assets. Si cambias algo en esa carpeta, se reflejará automáticamente en el navegador. También puedes cambiar tus archivos de vista sin reiniciar Sails porque las plantillas no se almacenan en la memoria.

$ sails lift

Obtendrás la siguiente salida cuando se inicie con éxito la aplicación.

 info: Starting app...

 info: Initializing project hook... (`api/hooks/custom/`)
 info: Initializing `apianalytics` hook...  (requests to monitored routes will be logged!)
 info: ·• Auto-migrating...  (alter)
 info:    Hold tight, this could take a moment.
 info:  ? Auto-migration complete.

debug: Running v0 bootstrap script...  (looks like this is the first time the bootstrap has run on this computer)
 info:
 info:                .-..-.
 info:
 info:    Sails              <|    .-..-.
 info:    v1.5.3              |\
 info:                       /|.\
 info:                      / || \
 info:                    ,'  |'  \
 info:                 .-'.-==|/_--'
 info:                 `--'-------'
 info:    __---___--___---___--___---___--___
 info:  ____---___--___---___--___---___--___-__
 info:
 info: Server lifted in `/home/navjot/howtoforge-app`
 info: To shut down Sails, press <CTRL> + C at any time.
 info: Read more at https://sailsjs.com/support.

debug: -------------------------------------------------------
debug: :: Tue Aug 23 2022 09:01:32 GMT+0000 (Coordinated Universal Time)

debug: Environment : development
debug: Port        : 1337
debug: -------------------------------------------------------

Sails.js expone tu aplicación al puerto 1337. Tendrás que abrir el puerto para acceder a la aplicación. Lanza otro terminal a tu servidor y ejecuta el siguiente comando para abrir el puerto.

$ sudo ufw allow 1337

Inicia la URL http://<serverIP>:1337 en tu navegador. Obtendrás la siguiente página.

Página de demostración de la aplicación Sails.js

Pulsa Ctrl + C en el terminal para cerrar la aplicación Sails.

Paso 6 – Crea un archivo de servicio systemd

Ahora mismo, la aplicación Sails sólo funciona si el terminal está activo. Para mantenerla persistente a través de los reinicios, necesitamos crear un archivo de servicio systemd para Sails.

Crea y abre el archivo howtoforge-app.service para editarlo.

$ sudo nano /etc/systemd/system/howtoforge-app.service

Pega en él el siguiente código.

[Unit]
After=network.target

[Service]
Type=simple
User=navjot
WorkingDirectory=/home/navjot/howtoforge-app
ExecStart=/home/navjot/.nvm/versions/node/v16.17.0/bin/node app.js
Restart=on-failure

[Install]
WantedBy=multi-user.target

Sustituye los valores de las variables User, WorkingDirectory y ExecStart por el nombre de usuario de tu sistema, la ruta de la aplicación y la ruta de tu aplicación node. Para localizar la ruta a Node.js, puedes utilizar el siguiente comando.

$ which node
/home/navjot/.nvm/versions/node/v16.17.0/bin/node

Estamos utilizando Node.js en lugar de la aplicación Sails CLI porque es más fácil configurarla y ejecutarla mediante un script del sistema. Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Recarga el demonio del sistema para aplicar los cambios.

$ sudo systemctl daemon-reload

Inicia el servicio Sails.js y haz que se inicie al arrancar el sistema.

$ sudo systemctl enable howtoforge-app --now

Comprueba el estado del servicio.

$ sudo systemctl status howtoforge-app
? howtoforge-app.service - Sails.js Howtoforge App
     Loaded: loaded (/etc/systemd/system/howtoforge-app.service; enabled; vendor preset: enabled)
     Active: active (running) since Tue 2022-08-23 11:52:58 UTC; 5s ago
   Main PID: 15385 (node)
      Tasks: 22 (limit: 2237)
     Memory: 123.8M
        CPU: 3.894s
     CGroup: /system.slice/howtoforge-app.service
             ??15385 /home/navjot/.nvm/versions/node/v16.17.0/bin/node app.js
             ??15392 grunt "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ">

Aug 23 11:53:01 sails node[15385]:  info:  ____---___--___---___--___---___--___-__
Aug 23 11:53:01 sails node[15385]:  info:
Aug 23 11:53:01 sails node[15385]:  info: Server lifted in `/home/navjot/howtoforge-app`
Aug 23 11:53:01 sails node[15385]:  info: To shut down Sails, press <CTRL> + C at any time.
Aug 23 11:53:01 sails node[15385]:  info: Read more at https://sailsjs.com/support.
Aug 23 11:53:01 sails node[15385]: debug: -------------------------------------------------------
Aug 23 11:53:01 sails node[15385]: debug: :: Tue Aug 23 2022 11:53:01 GMT+0000 (Coordinated Universal Time)
Aug 23 11:53:01 sails node[15385]: debug: Environment : development
Aug 23 11:53:01 sails node[15385]: debug: Port        : 1337
Aug 23 11:53:01 sails node[15385]: debug: -------------------------------------------------------

Puedes verificar el servicio abriendo la URL http://<serverIP>:1337 en tu navegador.

Paso 7 – Instalar Nginx

Ubuntu 22.04 viene con una versión antigua de Nginx. Para instalar la última versión, necesitas descargar el repositorio oficial de Nginx.

Importa la clave de firma de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Añadir el repositorio de la versión estable de Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Actualiza los repositorios del sistema.

$ sudo apt update

Instalar Nginx.

$ sudo apt install nginx

Verificar la instalación.

$ nginx -v
nginx version: nginx/1.22.0

Paso 8 – Instalar SSL

Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot utilizando el repositorio de Ubuntu o coger la última versión utilizando la herramienta Snapd. Nosotros utilizaremos la versión Snapd.

Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd está actualizada.

$ sudo snap install core
$ sudo snap refresh core

Instala Certbot.

$ sudo snap install --classic certbot

Utiliza el siguiente comando para asegurarte de que el comando Certbot puede ejecutarse creando un enlace simbólico al directorio /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Ejecuta el siguiente comando para generar un certificado SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d sails.example.com

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/sails.example.com de tu servidor.

Genera un certificado de grupo Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Abre el archivo /etc/letsencrypt/renewal/sails.example.com.conf para editarlo.

$ sudo nano /etc/letsencrypt/renewal/sails.example.com.conf

Pega el siguiente código en la parte inferior.

pre_hook = systemctl stop nginx
post_hook = systemctl start nginx

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando te lo pida.

Hemos generado el certificado SSL utilizando la opción autónoma de Certbot. Ejecuta su servidor web para crear el certificado, lo que significa que Nginx debe estar apagado durante la renovación. Los comandos pre_hook y post_hook se ejecutan antes y después de la renovación para cerrar y reiniciar automáticamente el servidor Nginx, por lo que no es necesaria la intervención manual.

Para comprobar si la renovación de SSL funciona bien, haz una ejecución en seco del proceso.

$ sudo certbot renew --dry-run

Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.

Paso 9 – Configurar Nginx

Abre el archivo /etc/nginx/nginx.conf para editarlo.

$ sudo nano /etc/nginx/nginx.conf

Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando te lo pida.

Crea y abre el archivo /etc/nginx/conf.d/sails.conf para editarlo.

$ sudo nano /etc/nginx/conf.d/sails.conf

Pega en él el siguiente código. Sustituye sails.example.com por el nombre de tu dominio. Asegúrate de que el valor de client_max_body_size está ajustado a 10MB. Cámbialo según tus necesidades.

upstream backend {
   server 127.0.0.1:1337;
   keepalive 32;
}

server {
  listen 80 default_server;
  server_name sails.example.com;
  return 301 https://$server_name$request_uri;
}

server {
   listen 443 ssl http2;
   server_name sails.example.com;

   http2_push_preload on; # Enable HTTP/2 Server Push

   ssl_certificate /etc/letsencrypt/live/sails.example.com/fullchain.pem;
   ssl_certificate_key /etc/letsencrypt/live/sails.example.com/privkey.pem;
   ssl_trusted_certificate /etc/letsencrypt/live/sails.example.com/chain.pem;
   ssl_session_timeout 1d;

   # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
   # prevent replay attacks.
   #
   # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
   ssl_early_data on;

   ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
   ssl_prefer_server_ciphers on;
   ssl_session_cache shared:SSL:50m;
   # OCSP Stapling ---
   # fetch OCSP records from URL in ssl_certificate and cache them
   ssl_stapling on;
   ssl_stapling_verify on;
   ssl_dhparam /etc/ssl/certs/dhparam.pem;

   add_header X-Early-Data $tls1_3_early_data;
   
   access_log /var/log/nginx/sails.access.log main;
   error_log  /var/log/nginx/sails.error.log;

   location / {
       client_max_body_size 10M;
       proxy_set_header Host $http_host;
       proxy_set_header Upgrade $http_upgrade;
       proxy_set_header Connection "upgrade";
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
       proxy_set_header X-Frame-Options SAMEORIGIN;
       proxy_buffering off;
       proxy_http_version 1.1;
       proxy_pass http://backend;
   }
}

# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Comprueba la configuración de Nginx.

$ sudo nginx -t

Reinicia el servidor Nginx.

$ sudo systemctl restart nginx

Paso 10 – Accede a la aplicación Sails.js

Inicia la URL https://sails.example.com en tu navegador y te aparecerá la página de inicio de Sails.

Haz clic en el botón de Registro en la parte superior derecha para crear una nueva cuenta.

Aplicación Sails Página de creación de cuenta

Rellena los datos de tu cuenta y haz clic en el botón Crear cuenta para terminar.

Inmediatamente aparecerá la pantalla de bienvenida.

Página de bienvenida a la cuenta de la aplicación Sails

Ahora puedes empezar a utilizar la aplicación para crear una aplicación dinámica con autenticación de usuarios, soporte de base de datos y una pasarela de pago incorporada impulsada por Stripe.

Conclusión

Esto completa el tutorial en el que has aprendido a instalar el framework Sails.js y a crear una aplicación de demostración. También has aprendido a configurar un servicio systemd para ella y a utilizar el servidor proxy Nginx con Let’s Encrypt para lanzar una aplicación web segura. Si tienes alguna pregunta, publícala en los comentarios a continuación.

Scroll al inicio