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.
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.
Rellena los datos de tu cuenta y haz clic en el botón Crear cuenta para terminar.
Inmediatamente aparecerá la pantalla de bienvenida.
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.