Recientemente migré algunas pruebas de Jest al ejecutor de pruebas de Node.js en dos de mis proyectos que usan MongoDB. En uno de esos proyectos, el tiempo de ejecución de las pruebas fue reducido de 107 segundos a 25 segundos (captura de pantalla abajo). En el otro proyecto, el tiempo de ejecución de las pruebas fue reducido cerca de un 66%.

Decidí compartirte cómo pude implementarlo. Pienso que te será de utilidad, ya que es más rentable (en términos de reducir dinero gastado en ejecutar pruebas en CI/CD), y también mejora tu experiencia de desarrollo.

Tabla de Contenidos

• Pre-requisitos
• El Ejecutor de Pruebas de Node.js
• El Servidor en memoria de MongoDB

• Cómo escribir las Pruebas
  1. Configurar el Proyecto
  2. Configurar el Esquema de Mongoose
  3. Configurar los Servicios
  4. Configurar las Pruebas
  5. Escribir las Pruebas
  6. Pasar las Pruebas
  7. Usar TypeScript (Opcional)

• Conclusión

Pre-requisitos

Para seguir esta guía, deberías de tener experiencia trabajando con Node.js, MongoDB y Mongoose (o cualquier otro mapeador de datos de objetos de MongoDB). Deberías también tener instalado Node.js (al menos la versión 20.18.2) y MongoDB (Compass la versión GUI) en tu computadora.

El Ejecutor de Pruebas de Node.js

El ejecutor de pruebas de Node.js fue introducido como una característica experimental en la versión 18 de Node.js. Se volvió disponible oficialmente en la versión 20. Te da la habilidad de:

1. Ejecutar pruebas
2. Reportar resultados de las pruebas
3. Reportar cobertura de las pruebas (todavía experimental en la versión 23)

Es una buena idea el usar el ejecutor de pruebas incorporado cuando se escriban pruebas en Node.js porque significa que tienes que usar menos dependencias externas. No necesitas instalar una librería externa (y sus dependencias entre pares) para ejecutar las pruebas.

El mejor ejecutor incorporado también es el más rápido. Basado en mi experiencia usándolo en dos proyectos (los cuales usaron Jest), vi mejoras de al menos una reducción del 66% en el tiempo que tomó ejecutar las pruebas completamente.

Y a diferencia de otros frameworks o librerías de pruebas, el ejecutor de pruebas de Node.js fue construido especialmente para proyectos de Node.js. No trata de acomodar las especificaciones de otros entornos de programación como el navegador. Las especificaciones de Node.js son su principal y única prioridad.

El Servidor en memoria de MongoDB

Para las pruebas que involucran el hacer peticiones a una base de datos, algunos desarrolladores prefieren imitar las peticiones para evitar hacer peticiones a una base de datos real. Hacen esto porque hacer una petición a una base de datos real requiere un montón de configuraciones que puede costar tiempo y recursos.

Escribir y solicitar datos usando una base de datos real es más lento comparado con escribir y solicitar datos de la memoria. Cuando se ejecutan pruebas automatizadas, usando un servidor de MongoDB real será más lento que usar un servidor de base de datos en memoria, y ahí es donde mongodb-memory-server se vuelve útil.

Según su documentación, mongodb-memory-server crea y comienza un servidor de MongoDB real de forma programática desde dentro de Node.js, pero usa una base de datos en memoria por defecto. También te permite conectar el servidor de base de datos que crea usando tu mapeador de datos de objetos preferido tales como Mongoose, Prisma, o TypeORM. En esta guía, usaremos Mongoose (v.8.9.6).

Ya que los datos almacenados por mongodb-memory-server reside en la memoria por defecto, es más rápido leer y escribir en él que cuando se usa una base de datos real. mongodb-memory-server también es más fácil de configurar. Estos beneficios lo hace una buena elección para usarlo como un servidor de base de datos para escribir pruebas.

Nota: asegúrate de instalar la versión 9.1.6 de mongodb-memory-server para seguir esta guía. La versión 10 actualmente tiene problemas con limpiar los recursos después que se hacen las pruebas. Mira este problema con el título "Node forking will include any --import from the original command".

El problema ha sido resuelto al tiempo de escribir este artículo, pero el arreglo no ha sido fusionado para las instalaciones.

Cómo escribir las Pruebas

Ahora te guiaré a través de los siguientes pasos para que comiences a escribir las pruebas:

1. Configurar el proyecto
2. Configurar el esquema de Mongoose
3. Configurar los servicios
4. Configurar las pruebas
5. Escribir las pruebas
6. Pasar las pruebas
7. Usa TypeScript (Opcional)

1. Configurar el Proyecto

Creé un repositorio de Github para facilitarte que sigas esta guía. Clona este repositorio en nodejs-test-runner-mongoose y dirígete a la rama 01-setup.

En 01-setup, las dependencias para el proyecto están el archivo package.json. Instala las dependencias usando el comando npm install para configurar el proyecto. Asegúrate de que la configuración esté completa y correcta, ejecuta el comando node . en la terminal de tu proyecto. Deberías ver tu versión de Node.js  como una salida en la terminal.

# instala las dependencias
npm install
...
# ejecuta el comando node
node .
# la salida
You are running Node.js v22.13.1

2. Configurar el Esquema de Mongoose

Configuraremos el esquema para dos colecciones (Task y User) en la rama 02-setup-schema usando Mongoose. Los archivos task/model.mjs y user/model.mjs contienen el esquema para las colecciones Task y User, respectivamente. También configuraremos una conexión de base de datos en index.mjs para asegurar que la configuración del esquema funcione correctamente.

No iré en detalle sobre los modelos y esquemas de Mongoose en este artículo porque están fuera de su alcance.

Cuando ejecutas el comando node . después de implementar los cambios en 02-setup-schema, deberías de ver un resultado similar en la consola como en el fragmento de abajo:

node .
You are running Node.js v22.13.1
Created user with id 679f1d7f73fbeaf23b2007df
Created task "Task title" for user with id "679f1d7f73fbeaf23b2007df"

Puedes ver las diferencias entre 01-setup y 02-setup-schema a través de la diferencia 01-setup <> 02-setup-schema en Github.

3. Configurar los Servicios

Luego, creamos los archivos de servicio (task/service.mjs y user/service.mjs) en la rama 03-setup-services. Ambos archivos actualmente contienen funciones vacías en el que escribiremos las pruebas más tarde. Estas funciones contendrán la lógica de negocio y también se comunicará con la base de datos. Estamos usando comentarios de JSDoc para escribir parámetros y regresar valores.

Haz clic en la diferencia de 02-setup-schema <> 03-setup-services para ver los cambios de código entre 02-setup-schema y 03-setup-services.

4. Configurar las Pruebas

En la rama 04-set-up-tests, configuramos la base de código para ejecutar las pruebas. Creamos test.setup.mjs el cual contiene el código que será ejecutado antes de que cada archivo de prueba se ejecute.

En test.setup.mjs, la función connect crea un servidor de MongoDB en memoria y lo conecta con Mongoose para ejecutar las pruebas. La función closeDatabase cierra la conexión de la base de datos y limpia todos los recursos para liberar memoria.

Las funciones connect y closeDatabase se ejecutan en el hook t.before y en el hook t.after respectivamente. Esto asegura eso, antes que un archivo test se ejecute, una conexión de base de datos se establece a través t.before. Luego de que se hayan ejecutado las pruebas del archivo, la conexión de la base de datos se cae y los recursos usados se limpian a través de t.after.

En package.json, actualizaremos el script de npm test a node --test --import ./test.setup.mjs. Este comando asegura que Módulo Es test.setup.mjs se pre-cargue y se ejecute a través del comando --import del CLI antes de que cada archivo de prueba se ejecute.

Luego crearemos los archivos de prueba con pruebas vacías en las carpetas __tests__ para user y task. Después de implementar los nuevos cambios en 04-set-up-tests, ejecutar el script test con npm run test debería de mostrar la salida similar al fragmento de abajo:

npm run test

> nodejs-test-runner-mongoose@1.0.0 test
> node --test --import ./test.setup.mjs

...

ℹ tests 8
ℹ suites 5
ℹ pass 8
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 941.768873

Todas las pruebas actualmente pasan porque no hay aserciones que fallen. Escribiremos las pruebas con aserciones en la siguiente sección.

5. Escribir Pruebas

Ahora es tiempo de escribir las pruebas para las funciones en los archivos de service en la rama 05-write-tests. Estamos usando la librería de aserción de Node.js para asegurar que los valores regresados de las funciones sean lo que esperamos. Puedes ver las pruebas que hemos escrito cuando comparas las diferencias entre 04-set-up-tests y 05-write-tests.

Cuando el script tests se ejecute, todas las pruebas fallan porque no hemos escritos las funciones en los archivos de service todavía. Debería de ver una salida similar al fragmento de abajo cuando ejecutes el script test:

npm run test

> nodejs-test-runner-mongoose@1.0.0 test
> node --test --import ./test.setup.mjs

...

ℹ tests 8
ℹ suites 5
ℹ pass 0
ℹ fail 8
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 1202.031961

6. Pasar las Pruebas

En 06-pass-tests, escribimos las funciones en los archivos de service que pasen las pruebas. Solamente 6 de 7 pruebas pasan cuando el script test se ejecuta porque salteamos la prueba para la función getById en user/service.mjs con t.skip. No hemos terminado la función getById en user/service.mjs. Supuse que podríamos dejarlo como ejercicio.

Cuando ejecutas el script test, deberías obtener una salida similar en la terminal como el de abajo:

ℹ tests 7
ℹ suites 4
ℹ pass 6
ℹ fail 0
ℹ cancelled 0
ℹ skipped 1
ℹ todo 0
ℹ duration_ms 1287.564918

Puedes ver el código que escribimos para pasar las pruebas en los cambios de código entre 05-write-tests y 06-pass-tests.

7. Usa TypeScript (Opcional)

Si tu intención es ejecutar las pruebas con TypeScript, puedes cambiar a la rama 07-with-typescript. Necesitas tener Node.js >=22.6.0 instalado porque estamos usando la opción --experimental-strip-types en el test. Para configurar las pruebas que se ejecuten con TypeScript, sigue los siguientes pasos:

1. Instala TypeScript usando el comando npm install typescript --save-dev
2. Instala tsx usando el comando npm install tsx
3. Crea un archivo predeterminado tsconfig.json en la raíz del proyecto usando el comando npx tsc --init

En  package.json, actualiza el script test a esto:

"test": "node --test --experimental-strip-types --import tsx --import ./test.setup.mjs"

• --experimental-strip-types ayuda a eliminar tipos antes de cada archivo de prueba se ejecute.

Pre-cargar tsx con el --import ayuda a ejecutar el archivo de TypeScript. Sin él, el ejecutor de pruebas no será capaz de encontrar archivos importados sin la extensión .ts. Por ejemplo, user/model.ts importado con el fragmento de código de abajo no será encontrado.

  import { UserModel } from "./model";

El resto de los cambios desde 06-pass-tests a 07-with-typescript involucran actualizar los tipos, cambiar las extensiones de archivo de .mjs a .ts y actualizar las declaraciones import.

Conclusión

En esta guía, has aprendido cómo usar el ejecutor de pruebas incorporado de Node.js y por qué es frecuentemente una mejor elección sobre otras librerías y frameworks de pruebas. También has aprendido cómo usar mongodb-memory-server como un reemplazo de un servidor real de MongoDB, así también como por qué es una buena idea usarlo en vez de un servidor real de MongoDB para las pruebas.

Lo más importante, has aprendido cómo configurar y ejecutar las pruebas en Node.js usando el ejecutor de pruebas de Node.js y mongodb-memory-server. Ahora deberías de saber cómo configurar tus proyectos para que ejecuten las pruebas si usas TypeScript.

Si encuentras útil a este repositorio nodejs-test-runner-mongoose, por favor dale una estrella. Me anima mucho. Gracias.

Pero ¿por qué es eso relevante? JavaScript se volvió mucho más rápido con un nuevo entorno de ejecución de JavaScript llamado Bun, que ahora está listo para producción con su versión 1.0.

¿Cómo y por qué es más rápido que Node.js? Me vienen a la mente muchas preguntas.

Responderé algunas de esas preguntas en este artículo. Y lo haré rápidamente, ya que ahora soy más rápido, al igual que JavaScript, que se prepara con Bun 1.0.

Bun es un conjunto de herramientas rápidas todo en uno para ejecutar, crear, probar y depurar JavaScript y TypeScript, desde un único archivo hasta una aplicación full-stack.

A continuación algunas cosas que podemos hacer con Bun:

Ejecuta tu código más rápido con Bun

Ahora no necesitamos herramientas como npm, pnpm o yarn porque Bun es 17 veces mas rápido. Eche un vistazo a los datos mostrados a continuación:

Bun tarda solo 0,36 segundos en compilar su código, mientras que tarda unos 6,44 segundos en el caso de pnpm, 10,58 segundos con npm y 12,08 segundos con yarn.

Bun soporta hot reloading

Bun soporta hot reloading (recarga en caliente) desde el primer momento, por lo que no necesita herramientas como Nodemon. Actualizará automáticamente el servidor cuando se ejecute JavaScript o TypeScript.

Puede reemplazar el comando npm run con bun run para ahorrar más de 150 ms milisegundos cada vez que ejecuta un comando.

Aquí un gráfico completo:

Según el cuadro anterior, el uso de npm tarda unos 176 ms en ejecutarse, yarn tarda unos 131 ms. En el caso de pnpm, se necesitan 259 ms. Sin embargo, en el caso de Bun, se necesitan unos 7 ms. Eso es rápido, ¿no?

Bun es un empaquetador JavaScript

Bun también es un empaquetador de JavaScript con el mejor rendimiento de su clase y una API compatible con ESBuild, por lo que no necesitamos cosas como:

• ESBuild
• Webpack
• Parcel, .parcelrc
• Rollup, rollup.config.js

Bun ahora soporta Next.js, Remix, Nuxt, Astro, SvelteKit, Nest, SolidStart y Vite.

Bun es compatible con ESM y CommonJS

Otra gran característica de Bun es que podemos usar módulos ES6 y CommonJs juntos en el mismo archivo, lo que no era posible en Node.js.

Puedes usar import y require() en el mismo archivo:

import lodash from "lodash";
const _ = require("underscore");

Aparte de eso, Bun tiene soporte integrado para las API estándar web que están disponibles en los navegadores, como fetch, junto con la propia API de Bun como Bun.file() para leer un archivo de forma diferida y Bun.Write() para escribir un archivo al sistema de archivos local, que es mucho más simple que Node.js.

Ejemplo Bun.file()

const archivo = Bun.file("package.json");
const contenido = await archivo.text();

El código anterior leerá el contenido de un archivo package.json y transferirá su contenido a una nueva variable llamada contenido.

Ejemplo Bun.write()

await Bun.write("index.html", "<html/>");
await Bun.write("index.html", Buffer.from("<html/>"));
await Bun.write("index.html", Bun.file("home.html"));
await Bun.write("index.html", 
await fetch("https://ejemplo.com/"));

En el código anterior, Bun.write() escribirá la cadena "<html/>", o copiará el contenido del archivo home.html en el archivo index.html. Si tenemos que recuperar datos, obtendrá los resultados de una API web externa y escribirá el contenido en un archivo index.html.

¿Por que Bun es tan rápido?

Bun es rápido porque usa el motor JavaScriptCore, mientras que Node.js usa el motor JavaScript V8. El primero se ha optimizado para un tiempo de inicio más rápido.

Si deseas hacer las cosas más rápido, debería considerar reemplazar Node.js con Bun.

¿Cómo empezar a usar Bun?

Puedes instalar Bun en sistemas MacOS y Linux usando npm:

npm install -g bun

Ahora ya está todo listo. Para instalar un paquete npm, haz esto:

bun install <nombre-paquete>

Para iniciar una aplicación, haz esto:

bun run dev

Para todo lo que pueda necesitar solo reemplace npm con bun.

Sin embargo, Bun sólo está listo para producción en los sistemas operativos MacOS y Linux. La versión de Windows aún es experimental. Por el momento, solo se admite el entorno de ejecución de JavaScript para Windows, y no el administrador de paquetes, el empaquetador ni el entorno de pruebas. Puedes leer más al respecto aquí.

Conclusión

Este artículo muestra cómo puedes utilizar Bun como alternativa a Node.js y acelerar su tiempo de desarrollo.

También puedes ver mi vídeo sobre El asesino de Node.js está aquí — Primer vistazo a Bun 1.0 (en inglés).

Gracias por leer.

Si deseas profundizar en cuanto a como funciona una API REST, sus elementos y particularidades, puedes consultar este artículo de freecodecamp.org, que describe de forma detallada los conceptos anteriormente mencionados.

Cuando construimos una API REST, debemos identificar que datos para gestionar, en nuestro caso, vamos a tomar como ejemplo un sistema de gestión de tickets, que tendría un modelo de datos similar al que vemos en el siguiente diagrama:

Tomando en cuenta lo indicado, a partir del modelo entidad-relación anterior, es importante identificar los elementos que van a actuar como componentes de nuestra API REST.

Elementos componentes de una API REST

Vamos a identificar 3 componentes principales en la construcción de una API REST, estos son:

• Modelos, que serán las representación de las entidades que iremos a gestionar en la API, es la abstracción de los datos del mundo real al mundo digital.
• Controladores, responsables de implementar las operaciones a realizar sobre los modelos, a veces denominada capa de lógica de negocios.
• Rutas, definiciones de como nuestra API puede interactuar con el mundo exterior, es decir a través de las rutas definimos la comunicación entre la implementación que vamos a realizar con los servicios o herramientas que irán a consumir lo que realicemos.

Para construir esta API vamos a usar NodeJS, que es el entorno de ejecución de javascript para backend.

Definiendo a NodeJS

Según la web oficial de nodejs.org, la definición de Node es:

Ideado como un entorno de ejecución de JavaScript orientado a eventos asíncronos, Node.js está diseñado para crear aplicaciones network escalables.

En el siguiente material tendrás algunas orientaciones básicas de como funciona y como realizar la instalación del mismo.

Qué es Fastify

Partiendo de los elementos indicados como componentes de una API, vamos a explicar que paquetes vamos a utilizar para la implementacion de cada uno de ellos. Comencemos por el responsable de las rutas o mejor en forma general, por la comunicación y transporte de datos.

Es a través de este proceso (comunicación y transporte) que nuestra API REST  va a recibir y enviar datos a quien esté consumiendo el servicio. Esto se hace a través de rutas.

Para esta tarea tenemos varias opciones, como usar las clases nativas de NodeJS, usar el framework expressjs o  en nuestro caso usar el framework fastify. Te preguntaras por qué Fastify?. Varias razones: simplicidad, rapidez y escabilidad del framework.

Primero vamos a crear nuestro proyecto node, con la siguiente instrucción:

npm init

Ahora avancemos a la instalación de fastify, esta muy simple, sólo ejecutanos el siguiente comando y con ello ya en nuestro proyecto podemos usar sus métodos y funcionalidades, pero comencemos por crear el proyecto:

npm install fastify

Ahora procedemos a construir el esqueleto de nuestra API.

Construyendo los elementos de nuestra API REST

Empecemos por el archivo principal, el cual será: index.js El contenido del archivo index.js será:

import Fastify from 'fastify';

const fastify = Fastify({
    logger: true
});

// Ruta inicial
fastify.get('/', async function handler (req, res) {
    return { hello: 'world' };
});
  
// Ejecución de la aplicación
try {
    await fastify.listen({ port: 3000 });
} catch (err) {
    fastify.log.error(err);
    process.exit(1);
}

Con lo anterior, ya tenemos en pocas líneas, una API funcional, que solo tiene una ruta, pero que en esencia está completa. Ahora pasemos a la extensión de sus rutas.

Definiendo las rutas básicas

Procedemos entonces a definir las rutas que nuestra API va a implementar, en este caso creamos un nuevo archivo llamado routes.js, en el cual definimos los CRUDs de cada uno de nuestros modelos, siendo que CRUD será (C-reate, R-ead, U-pdate, D-elete), en español serán las operaciones de Inserción, Lectura, Actualización y Borrado.

El archivo quedará de esta forma:

const rutas = [
    {
        method: "POST",
        url: "/usuarios",
        handler: async (req, res) => {
            res.status(200).send({status: 'OK - POST'});
        }
    },
    {
        method: "GET",
        url: "/usuarios",
        handler: async (req, res) => {
            res.status(200).send({status: 'OK - GET'});
        }
    },
    {
        method: "PUT",
        url: "/usuarios/:id",
        handler: async (req, res) => {
            res.status(200).send({status: 'OK - PUT'});
        }
    },
    {
        method: "DELETE",
        url: "/usuarios/:id",
        handler: async (req, res) => {
            res.status(200).send({status: 'OK - DELETE'});
        }
    }
]

export default rutas;

Observa que algunas rutas tienen :/id, esto lo explicaremos en detalle más adelante.

Con las rutas ya definidas, el siguiente paso será definir los modelos, notese que en el archivo anterior, dejamos la propiedad handler apuntando a una función básica que siempre retorna OK.

handler: (req,res) => {
	res.status(200).send('OK');
}

Esto significa que por ahora no tenemos ningún proceso asociado a las rutas, pero hemos dejado ya la estructura hecha. La implementación será realizada más adelante.

Incorporemos las rutas a nuestro archivo principal index.js, quedando este de la siguiente forma:

import Fastify from 'fastify';
import rutas from './rutas.js';
import cors from '@fastify/cors';

const fastify = Fastify({logger:true});
await fastify.register(cors, {

});

//POST - Inserciones                C-REATE
//GET - Consulta                    R-EAD
//PUT, PATCH - Actualizaciones      U-PDATE
//DELETE - Borrado                  D-ELETE

fastify.get("/",async function(req, res) {
    return { hello: 'world'};
});

//Incorporación de las rutas
rutas.forEach((ruta) => {
    fastify.route(ruta);
});

try {
    fastify.listen({port:3500});
} catch(erro) {
    console.log(erro);
}

En el siguiente material podrás visualizar el paso de la construcción que hemos hecho hasta ahora.

Modelos

Acá vamos a definir los datos que nuestra API procesará, tomemos la primera entidad "Usuarios" y definamos su modelo, para ello nos vamos a apoyar en sequelize, que nos permite hacer una definición que luego se reflejará en la base de datos, esto debido a que Sequelize actua como un ORM (Object Relation Mapping).

Pero qué es un ORM - Object Relation Mapping?

Tomando lo que https://en.wikipedia.com nos indica, podemos citar lo que es un ORM:

Un ORM (Object-Relational Mapping) es una técnica de programación que permite la conversión de datos entre una base de datos relacional y un lenguaje de programación orientado a objetos. En otras palabras, un ORM es una herramienta que ayuda a simplificar la traducción entre los dos paradigmas: objetos y tablas de bases de datos relacionales. Puede utilizar definiciones de clases (modelos) para crear, mantener y proporcionar acceso completo a los datos de los objetos y su persistencia en la base de datos.

Instalando Sequelizer

Para realizar la instalación de Sequelizer, necesitamos ejecutar sólo este comnpm install sequelizerando:

npm install sequelizer

Ejecutando lo anterior, tenemos ya disponible el paquete en nuestro proyecto, es momento de conectar nuestra base de datos, para ello creamos un nuevo archivo llamado db.js y colocamos los parámetros de conexión correspondientes:

/* eslint-disable require-jsdoc */
import Sequelize from 'sequelize';

/*
Clase de conexión a la base de datos
*/
class DBInstance {
	constructor() {
		const dbCfg = {
			user: '<usuario_base_datos>',
			host: '<ip_o_dns_servidor>',
			database: '<nombre_base_datos>',
			password: '<clave_usuario_base_datos>',
			port: 5432,
		};
		this.sequelize = new Sequelize(dbCfg.database, dbCfg.user, dbCfg.password, {
			host: dbCfg.host,
			dialect: 'postgres',
			logging: false,
		});
	}
}

export default new DBInstance().sequelize;

Con lo anterior, ya tenemos conexión a nuestra base de datos. Ajustamos nuestro archivo index.js para importar este proceso de conexión y dejarlo ejecutandose cuando sea iniciada la API. Quedando su código de esta forma:

import Fastify from 'fastify';
import db from './db.js';
import rutas from './rutas.js';
import cors from '@fastify/cors';

const fastify = Fastify({logger:true});
await fastify.register(cors, {

});

//POST - Inserciones                C-REATE
//GET - Consulta                    R-EAD
//PUT, PATCH - Actualizaciones      U-PDATE
//DELETE - Borrado                  D-ELETE

// eslint-disable-next-line no-unused-vars
fastify.get('/',async function(req, res) {
	return { hello: 'world'};
});

//Incorporación de las rutas
rutas.forEach((ruta) => {
	fastify.route(ruta);
});

async function database() {
	try {
		await db.sync();
		console.log('Conectado a la base de datos');
	} catch(e) {
		console.log(e);
	}
}

try {
	fastify.listen({port:3500});
	database();
} catch(erro) {
	console.log(erro);
}

Observa que hemos creado una función asincrona llamada database() y luego al iniciar la API, la invocamos para que se realice la conexión y sincronización del modelo.

Ahora procedemos a crear el modelo, recordando que un modelo es la representación de los datos que vamos a gestionar del mundo real en nuestra API.

Comencemos por el modelo de Usuarios:

import sequelize from "sequelizer";

const User = sequelize.define("User", {
    id : {
        type: sequelize.STRING,
        allowNull: false,
        primaryKey: true,
    },
    fullname: {
        type: sequelize.STRING,
        allowNull: false,
    },
    password: {
        type: sequelize.STRING,
        allowNull: false,
    },
});

export default User;

Observa que cada propiedad del objeto que define el modelo, corresponde con el nombre del campo que definimos en nuestro modelo de entidad-relación al inicio del documento, el nombre de cada propiedad representa cada campo, así que debemos tener cuidado con el nombre que le indiquemos, mi recomendación usar letras minusculas, no usar caracteres especiales.

En el caso de password, vamos usar un paquete adicional, para poder encriptar el contenido de la misma, recordando que por seguridad, los datos de claves no se deben guardar de forma plana o legible en la base de datos.

Para lograr que nuestro password quede guardado de forma segura, hacemos uso del paquete bcrypt, el cual nos permite codificar el valor enviado por el usuario y luego con un método propio del paquete podemos validar si clave es la guardada, de esta forma el modelo de Usuarios queda implementado con el siguiente código:

import sequelize from 'sequelize';
import bcrypt from 'bcrypt';
import db from '../db.js';


const UserModel = db.define('users', {
  id: {
    type: sequelize.STRING,
    allowNull: false,
    primaryKey: true,
  },
  fullname: {
    type: sequelize.STRING,
    allowNull: false,
  },
  password: {
    type: sequelize.STRING,
    allowNull: false,
  },
}, {
  hooks: {
    beforeCreate: (user) => {
      const salt = bcrypt.genSaltSync();
      user.password = bcrypt.hashSync(user.password, salt);
    },
  },
});

UserModel.prototype.validPassword = function(password) {
  return bcrypt.compareSync(password, this.password);
};

export default UserModel;

Para el caso del modelo de tiendas o comercios, siguiendo lo definido anteriormente, el modelo queda representado con el siguiente código:

import sequelize from 'sequelize';
import db from '../db.js';

const StoreModel = db.define('stores', {
  id: {
    type: sequelize.INTEGER,
    autoIncrement: true,
    allowNull: false,
    primaryKey: true,
  },
  store_name: {
    type: sequelize.STRING,
    allowNull: false,
  },
  category_store: {
    type: sequelize.STRING,
    allowNull: false,
  },
});


export default StoreModel;

Algunas diferencias notorias, en el caso de id, usamos una propiedad dentro del objeto id que es autoIncrement, la cual define que el campo en la base de datos será del valor automático e incremental, de esta forma la base de datos asignará el id correspondiente. Otro punto interesante es el tipo de datos, en el caso de id usamos el tipo INTEGER, para definir que es un número entero.

Pasemos ahora al modelo de Tickets o Turnos, hacemos la implementación, recordando que este modelo se relaciona con Usuarios y Tiendas, de forma que un Usuario tiene N Tickets y una Tienda también tiene N Tickets, de esta forma el modelo implementado será:

import sequelize from 'sequelize';
import db from '../db.js';
import UserModel from './Users.js';
import StoreModel from './Stores.js';

const TicketModel = db.define('tickets', {
  id: {
    type: sequelize.STRING,
    allowNull: false,
    primaryKey: true,
  },
  date_time: {
    type: 'TIMESTAMP',
    allowNull: false,
  },
  status: {
    // eslint-disable-next-line new-cap
    type: sequelize.ENUM(['Creado', 'Confirmado', 'Atendido', 'Cancelado',
      'En progreso']),
    allowNull: false,
  },
  observation: {
    type: sequelize.TEXT,
    allowNull: false,
  },
  end_date_time: {
    type: 'TIMESTAMP',
    allowNull: false,
  },
});

UserModel.hasMany(TicketModel, {
  foreignKey: {
    name: 'user_id',
    type: sequelize.STRING,
    allowNull: false,
  },
});

StoreModel.hasMany(TicketModel, {
  foreignKey: {
    name: 'store_id',
    type: sequelize.INTEGER,
    allowNull: false,
  },
});


export default TicketModel;

En este modelo tenemos algunas particularidades que valen la pena analizar:

• Tenemos nuevos tipos de datos: TEXTpara almacenar grandes cantidad de datos (mayores a 255 caracteres), ENUM para definir un conjunto de valores cerrados para un campo en particular. TIMESTAMP para definir campos de tipo fecha/hora.
• Relaciones, en este modelo le decimos a sequelize que queremos relacionar los modelos en este segmento de código:

UserModel.hasMany(TicketModel, {
  foreignKey: {
    name: 'user_id',
    type: sequelize.STRING,
    allowNull: false,
  },
});

StoreModel.hasMany(TicketModel, {
  foreignKey: {
    name: 'store_id',
    type: sequelize.INTEGER,
    allowNull: false,
  },
});

Observa que se indica que el modelo Usuarios (UserModel) tiene muchos Tickets con la instrucción: hasMany, lo mismo sucede en el caso de Tiendas (StoreModel), le indicamos que va a tener múlples Tickets.

Con ellos hemos finalizado los modelos a implementar, ahora pasemos a la lógica de negocios.

Controladores

Estos elementos tan importantes a la hora de construir nuestra API REST, son los responsables de implementar lo que denominamos la lógica de negocios, es decir ellos reciben los datos enviados por quienes consumen el servicio o la API, los procesan, envian a la capa de datos cuando corresponde y retornan una respuesta.

De acuerdo con lo anterior, entonces en los controladores donde vamos a implementar el famoso CRUD (Create, Read, Update and Delete), el cual ya citamos anteriormente. Ahora bien, definamos la anatomía de un controlador:

import Model from "../models/Model.js";

class ModeloController {
    constructor() {

    }
    
    //Creación de registros
    async create (req, res)  {
    }
    
    //Consulta de todos los registros del modelo
    async getAll(req, res) {
    }

	//Consulta de un registro en particular
    async getOne(req, res) {
    }
    
    //Actualización de un registro
    async update(req, res) {
    }
    
    
    //Borrado de un registro
    async delete(req, res) {
    }
    
 }
    

Notemos que el controlador implementar como comentarmos anteriormente cada una de las operaciones del CRUD, que la API va a realizar para cada uno de los modelos construidos, de esta forma, vamos a tener que crear un controlador para usuarios, otro para tiendas y uno más para los tickets o turnos.

En este material realizamos la implementación de los modelos y parte de los controladores:

Ahora para cada modelo que hemos definido en nuestra API, construimos sus controladores, quedando su código de esta forma:

• UsersController

/* eslint-disable require-jsdoc */
import UserModel from '../models/Users.js';

class UsersController {
  constructor() {

  }

  async create(req, res) {
    try {
      const userModel = await UserModel.create(req.body);

      if (userModel) {
        res.status(200).send({status: true, id: userModel.id});
      }
    } catch (e) {
      res.status(500).send({error: e});
    }
  }

  async getAll(req, res) {
    try {
      const where = {...req.query};
      const usuarios = await UserModel.findAll({where});
      res.status(201).send(usuarios);
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al consultar usuarios'},
      );
    }
  }

  async getOne(req, res) {
    try {
      const {id} = req.params;

      const userModel = await UserModel.findByPk(id);

      if (userModel) {
        res.status(201).send(userModel);
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al consultar el usuario'},
      );
    }
  }

  async update(req, res) {
    try {
      const {id} = req.params;

      const userModel = await UserModel.update(req.body,
          {where: {id}});

      if (typeof (userModel[0]) !== 'undefined' && userModel[0] === 1) {
        res.status(201).send({
          status: true,
        });
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al actualizar el usuario'},
      );
    }
  }

  async delete(req, res) {
    try {
      const {id} = req.params;

      const userModel = await UserModel.destroy({where: {id}});

      if (userModel) {
        res.status(201).send({
          status: true,
        });
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al intentar borrar un usuario'},
      );
    }
  }
}

export default new UsersController();

Del código anterior podemos resaltar algunas caracteristicas:

• Todos los métodos son asincronos, es decir por ser operaciones de base de datos, estos procesos deben esperar resultados y recordamos que Javascript no espera a nadie por lo tanto usamos las palabras reservadas async e await para lograr ese objetivo.
• Encerramos el procesamiento o la lógica de cada operación entre las palabras try y catch de forma tal que cualquier error, lo podamos capturar y retornar a quien nos consume los servicios.
• En cada uno de los métodos de nuestros controladores, nos vamos a apoyar en métodos de Sequelize, que nos van a facilitar el acceso y la gestión de los datos a nivel de base de datos. En la creación usamos create, en la búsqueda usamos findAll, para conseguir un registro en particular usamos findByPk, para actualizar usamos update y para borrar usamos destroy.
• En las operaciones que envuelven acceso a un registro en particular usamos del objeto req la propiedad params, es decir usamos req.params para obtener el id del registro. Este parámetro lo definimos en la ruta.
• Cuando hacemos operaciones de envio de datos, sea en la creación o en la actualización, el cuerpo o data la recibimos en lo que se denomina el body de la requisición, esto se obtiene con req.body.

Veamos como ha quedado el controlador de tiendas:

import StoreModel from '../models/Stores.js';


/* eslint-disable require-jsdoc */
class StoreController {
  constructor() {

  }

  async create(req, res) {
    try {
      const storeModel = await StoreModel.create(req.body);

      if (storeModel) {
        res.status(201).send({status: true, id: storeModel.id});
      }
    } catch (e) {
      res.status(500).send(e);
    }
  }

  async getAll(req, res) {
    try {
      const where = req.query;

      const tiendas = await StoreModel.findAll({where});
      res.status(201).send(tiendas);
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al consultar tiendas'},
      );
    }
  }

  async getOne(req, res) {
    try {
      const {id} = req.params;

      const storeModel = await StoreModel.findByPk(id);
      if (storeModel) {
        res.status(201).send(storeModel);
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al consultar la tienda'},
      );
    }
  }

  async update(req, res) {
    try {
      const {id} = req.params;
      const data = {...req.body};

      delete data.id;

      const storeModel = await StoreModel.update(data,
          {where: {id}});

      if (typeof (storeModel[0]) !== 'undefined' && storeModel[0] === 1) {
        res.status(201).send({
          status: true,
        });
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al actualizar la tienda'},
      );
    }
  }

  async delete(req, res) {
    try {
      const {id} = req.params;

      const storeModel = await StoreModel.destroy({where: {id}});

      if (storeModel) {
        res.status(201).send({
          status: true,
        });
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al intentar borrar una tienda'},
      );
    }
  }
}

export default new StoreController();

El controlador es bien similar al de usuarios, implementado en la clase UserController, solo en el método de actualización (update), agregamos está linea: delete data.id; para evitar que sea modificar el id interno del registro.

El controlador de Turnos, sigue a continuación, este controlador también tiene la protección para evitar que el campo autonumérico sea modificado en el método de actualización (update).

import TicketModel from '../models/Tickets.js';

/* eslint-disable require-jsdoc */
class TicketController {
	constructor() {

	}

	async create(req, res) {
		try {
			const ticketModel = await TicketModel.create(req.body);

			if (ticketModel) {
				res.status(201).send({status: true, id: ticketModel.id});
			}
		} catch (e) {
			res.status(500).send(e);
		}
	}

	async getAll(req, res) {
		try {
			const where = req.query;

			const tickets = await TicketModel.findAll({where});
			res.status(201).send(tickets);
		} catch (err) {
			res.status(500).send(
				{message: err.message || 'Error al consultar tickets'},
			);
		}
	}

	async getOne(req, res) {
		try {
			const {id} = req.params;

			const ticketModel = await TicketModel.findByPk(id);
			if (ticketModel) {
				res.status(201).send(ticketModel);
			} else {
				res.status(404).send(
					{message: 'Registro no encontrado'},
				);
			}
		} catch (err) {
			res.status(500).send(
				{message: err.message || 'Error al consultar el ticket'},
			);
		}
	}

	async update(req, res) {
		try {
			const {id} = req.params;
			const data = {...req.body};
			delete data.id;

			const ticketModel = await TicketModel.update(data,
				{where: {id}});

			if (typeof (ticketModel[0]) !== 'undefined' && ticketModel[0] === 1) {
				res.status(201).send({
					status: true,
				});
			} else {
				res.status(404).send(
					{message: 'Registro no encontrado'},
				);
			}
		} catch (err) {
			res.status(500).send(
				{message: err.message || 'Error al actualizar el ticket'},
			);
		}
	}

	async delete(req, res) {
		try {
			const {id} = req.params;

			const ticketModel = await TicketModel.destroy({where: {id}});

			if (ticketModel) {
				res.status(201).send({
					status: true,
				});
			} else {
				res.status(404).send(
					{message: 'Registro no encontrado'},
				);
			}
		} catch (err) {
			res.status(500).send(
				{message: err.message || 'Error al intentar borrar un ticket'},
			);
		}
	}
}

export default new TicketController();

Con esto hemos finalizado los controladores.

Rutas actualizadas

Ahora es momento de revisar como llamamos todo lo implementado en nuestras rutas, recordando que al inicio generamos las rutas para el módelo de usuarios, pero llamando a métodos genéricos en lugar de nuestros controladores, con ellos implementados, podemos ajustar el código, el cual queda de la siguiente forma:

import UsersController from './controllers/Users.js';
import StoreController from './controllers/Stores.js';
import TicketController from './controllers/Tickets.js';

const rutas = [
	{
		method: 'POST',
		url: '/usuarios',
		handler: UsersController.create,
	},
	{
		method: 'GET',
		url: '/usuarios',
		handler: UsersController.getAll,
	},
	{
		method: 'GET',
		url: '/usuarios/:id',
		handler: UsersController.getOne,
	},
	{
		method: 'PUT',
		url: '/usuarios/:id',
		handler: UsersController.update,
	},
	{
		method: 'DELETE',
		url: '/usuarios/:id',
		handler: UsersController.delete,
	},

	/* Rutas de tiendas */
	{
		method: 'POST',
		url: '/tiendas',
		handler: StoreController.create,
	},
	{
		method: 'GET',
		url: '/tiendas',
		handler: StoreController.getAll,
	},
	{
		method: 'GET',
		url: '/tiendas/:id',
		handler: StoreController.getOne,
	},
	{
		method: 'PUT',
		url: '/tiendas/:id',
		handler: StoreController.update,
	},
	{
		method: 'DELETE',
		url: '/tiendas/:id',
		handler: StoreController.delete,
	},

	/* Rutas de turnos */
	{
		method: 'POST',
		url: '/turnos',
		handler: TicketController.create,
	},
	{
		method: 'GET',
		url: '/turnos',
		handler: TicketController.getAll,
	},
	{
		method: 'GET',
		url: '/turnos/:id',
		handler: TicketController.getOne,
	},
	{
		method: 'PUT',
		url: '/turnos/:id',
		handler: TicketController.update,
	},
	{
		method: 'DELETE',
		url: '/turnos/:id',
		handler: TicketController.delete,
	},
];

export default rutas;

Interesante que nuestro archivo raiz index.js no sufre ninguna alteración, esto debido al grado de encapsulamiento y desacoplamiento que hemos implementado.

Con esto ya tenemos una API Rest funcional, implementada con NodeJS, Fastify, Sequelize y PostgreSQL.

Puedes verificar la implementación de los controladores y de todos sus métodos en este material:

En este tutorial, aprenderemos todo lo que necesitamos saber antes de implementar una aplicación Node en un servidor de producción.

Comenzaremos alquilando un servidor en Digital Ocean. Luego configuraremos este servidor, nos conectaremos a él, instalaremos Nginx y lo configuraremos, extraeremos o crearemos nuestra aplicación Node y la ejecutaremos como un proceso.

Como puedes ver, hay mucho que hacer y será un tutorial lleno de acción. Así que comencemos sin perder tiempo.

Debes tener algunos conocimientos básicos sobre cómo funciona la Terminal y cómo trabajar con Vi/Vim antes de comenzar. Si no estás familiarizado con los comandos básicos, te aconsejo que los leas un poco.

Ejecutaré los comandos en MacOS. Si quieres seguir este tutorial en Windows, puedes usar Powershell o algún otro emulador de Unix de tu elección.

Aunque usaré Node.js como plataforma de nuestra aplicación de ejemplo, la mayoría de los pasos son los mismos para cualquier aplicación web.

¿Por qué Digital Ocean?

Elijo Digital Ocean porque es barato y la interfaz es realmente fácil de usar, en comparación con AWS. Además, se incluye un crédito de $100 en el paquete de estudiante de GitHub para que no tengas que pagar nada durante un par de meses. Es ideal para implementar un curso o un proyecto de pasatiempos.

Tiene un concepto llamado Droplets, que es básicamente tu parte de un servidor. Puedes imaginar el servidor como un apartamento del que eres propietario o un apartamento alquilado.

Los droplets funcionan con la ayuda de máquinas virtuales que se ejecutan en el servidor. Entonces, un Droplet es tu máquina virtual en un servidor compartido. Dado que es una máquina virtual, su uso compartido de CPU y memoria se puede aumentar fácilmente, generalmente invirtiendo más dinero en tu proveedor.

Cómo crear un proyecto de Digital Ocean

Supongo que ya te has registrado e iniciado sesión en Digital Ocean antes de continuar. Primero debemos crear un proyecto que contenga nuestros droplets. Hagamos clic en el botón de nuevo proyecto en el menú del lado izquierdo. Te pedirá que nombres tu proyecto.

Introduce el nombre que quieras. También te preguntará si quieres mover algún recurso, pero por ahora simplemente haz clic en Omitir; crearemos el droplet más tarde.

Cómo crear un droplet en Digital Ocean

Vamos a crear nuestro droplet haciendo clic en el botón Comenzar.

Después de hacer clic en el botón, nos pedirá que elijamos una imagen de VM (Máquina virtual).

En esta página, seleccionaré Ubuntu 20.04, ya que es la última versión de LTS en el momento en que escribo esta publicación. LTS significa "Soporte a largo plazo" (por sus siglas en inglés). Lo mejor es optar por la versión LTS para proyectos reales, porque el proveedor garantiza que será compatible y mantenido durante mucho tiempo. Esto significa que no tendrás problemas a largo plazo.

Elegí Ubuntu y te lo recomendaría, ya que es la distribución de Linux más utilizada. Esto significa que también es más fácil encontrar respuestas a tus dudas futuras.

También puedes optar por tener una CPU dedicada si la necesitas. Si estás construyendo tu propia startup o cualquier proyecto comercial, te recomendaría leer esta publicación que contiene instrucciones detalladas sobre cómo elegir la opción adecuada para ti.

Seguiré con la opción más barata en este caso.

Luego, deberás seleccionar una región del centro de datos. Debes elegir el que esté más cerca de ti para minimizar el retraso de la red.

A continuación, seleccionemos Claves SSH como el Método de autenticación, ya que es mucho más seguro que la autenticación de contraseña básica.

Para conectarnos al servidor necesitamos generar una nueva clave SSH en nuestro propio dispositivo y agregarla a Digital Ocean.

Cómo generar una clave SSH

Generaré la clave en mi dispositivo macOS. Si estás utilizando Windows, puedes consultar este artículo. Abre tu terminal y muévete a la carpeta ssh:

cd ~/.ssh

Luego crea tu clave SSH:

ssh-keygen

Si tu computadora dice que no conoce este comando, debes instalarlo a través de brew.

Te pedirá que asignes un nombre al archivo e ingreses una frase de contraseña. No ingreses un nombre, solo presiona enter y sigue con los valores predeterminados. Deberías tener estos archivos generados. He nombrado el mío digital-ocean-ssh en esta captura de pantalla, así que no te confundas con eso.

❯ lsid_dsa      id_rsa      known_hosts

Nuestra clave pública es el id_dsa y el id_rsa es nuestra clave privada. Si olvidas cuál es la privada, siempre puedes imprimir una de ellas para verla.

Cómo agregar tu clave SSH a Digital Ocean

Ahora queremos copiar nuestra clave pública y subirla a Digital Ocean para que sepan qué clave usar en la autenticación.

Copia toda esta clave, incluida la parte ssh-rsa.

Haz clic en "Nueva clave SSH":

Pega la clave en el cuadro de texto que aparece después de hacer clic en el botón y deberías ver tu clave SSH.

Cómo conectarse al servidor

Usaremos la terminal para conectarnos a nuestro servidor con SSH. Si quieres también puedes echar un vistazo a Termius para obtener una buena interfaz.

Ejecuta este comando en tu terminal después de reemplazar IP_ADDRESS con la dirección IP de tu servidor (puedes buscarla desde el panel de Digital Ocean).

ssh root@IP_ADDRESS

Si todo va bien, ahora deberías estar en la terminal del servidor. Nos hemos conectado con éxito al servidor. Si hay algún error, puedes depurarlo ejecutando el comando con la opción "-v" o "-vv" para obtener aún más detalle.

Cómo configurar el servidor

Necesitamos hacer una configuración inicial antes de implementar la aplicación Node en el servidor.

Actualizar el software

Queremos actualizar el software del servidor para asegurarnos de que estamos usando las últimas versiones.

Muchos servidores son vulnerables a los ataques porque utilizan versiones anteriores de software con vulnerabilidades conocidas. Los atacantes pueden buscar las vulnerabilidades en ese software e intentar explotarlas para obtener acceso a tu servidor.

Puedes actualizar el software de Ubuntu usando el comando "apt update" .

apt updateHit:1 https://repos.insights.digitalocean.com/apt/do-agent main InReleaseGet:2 http://mirrors.digitalocean.com/ubuntu focal InRelease [265 kB]      Hit:3 http://mirrors.digitalocean.com/ubuntu focal-updates InRelease                Get:4 http://security.ubuntu.com/ubuntu focal-security InRelease [109 kB]Hit:5 http://mirrors.digitalocean.com/ubuntu focal-backports InReleaseFetched 374 kB in 1s (662 kB/s)                          Reading package lists... DoneBuilding dependency tree       Reading state information... Done96 packages can be upgraded. Run 'apt list --upgradable' to see them.

Si lees el mensaje, dice que "se pueden actualizar 96 paquetes". Hemos instalado los nuevos paquetes de software, pero aún no hemos actualizado nuestro software a esas versiones.

Para hacer eso, ejecutemos otro comando:

apt upgrade

Escribe 'y' cuando se te solicite y actualizarás el software.

Crear un usuario

Nos hemos conectado al servidor como el usuario root (el usuario con mayores privilegios). Ser root es peligroso y puede exponernos a vulnerabilidades.

Por lo tanto, debemos crear un nuevo usuario y no ejecutar comandos como root. Reemplaza $usernamecon un nombre de usuario de tu elección.

whoamiroot

adduser $username

Es necesario introducir una contraseña para el usuario. Después de ese punto, hará un montón de preguntas, así que sigue avanzando hasta que terminen las indicaciones.

Se ha creado el nuevo usuario, pero también debemos agregar este nuevo usuario al grupo "sudo" para que podamos realizar cualquier acción que necesitemos.

usermod -aG sudo $USERNAME

Agregamos grupo con la opción -aG (agregar grupo), y agregamos el nombre del grupo sudoa nuestro nombre de usuario.

Todavía somos root, así que cambiemos nuestro usuario al usuario recién creado, usando el comando su (cambiar de usuario).

su $USERNAME

Después de este punto, si ejecutas el comando whoami, deberías ver tu nombre de usuario. Puedes confirmar la existencia del grupo sudo ejecutando este comando:

sudo cat /var/log/auth.log

Solo los superusuarios pueden ver este archivo y el sistema operativo te pedirá tu contraseña de usuario después de ejecutar este comando.

Copia la clave SSH

Hemos creado correctamente el usuario, pero aún no hemos habilitado el inicio de sesión SSH para este nuevo usuario.

Por lo tanto, tenemos que copiar la clave pública que creamos previamente en nuestro ordenador local y pegarla en la carpeta SSH de este usuario para que SSH pueda saber qué clave debe usar para autenticar a nuestro nuevo usuario.

mkdir -p ~/.ssh

El argumento -p crea el directorio si no existe.

vi ~/.ssh/authorized_keys

Usaremos vi o vim para crear un archivo y llamarlo authorized_keys.

Copia tu clave pública (archivo `id_dsa`) y luego presiona "i" para entrar en el modo de inserción. Luego simplemente pégalo en este archivo con CMD + V (En Mac, si usas PC -> CTRL + V).

Presiona esc para salir del modo de inserción, escribe :wq para guardar y salir.

Si tienes algún problema con el uso de Vim-Vi, puedes consultar uno de los muchos tutoriales que explican cómo usarlo.

Conectarse al servidor con el nuevo usuario

Ahora deberíamos poder conectarnos al servidor sin ningún problema usando ssh. Puedes usar este comando para conectarte, solo recuerda insertar tu nombre de usuario ($USERNAME) y dirección ip (IP_ADDRESS).

ssh $USERNAME@IP_ADDRESS

Si tienes algún problema en este punto, simplemente debes eliminar el droplet y comenzar de nuevo. No toma mucho tiempo comenzar de nuevo, pero la depuración de problemas del servidor puede ser difícil.

Cómo deshabilitar el inicio de sesión con root

Es una buena práctica deshabilitar el inicio de sesión de root como medida de seguridad, así que hagámoslo ahora.

Puede ser útil cambiar el permiso del archivo por si acaso para que no tengamos problemas con los permisos en el futuro.

chmod 644 ~/.ssh/authorized_keys

Ahora abramos nuestro archivo sshd_config:

sudo vi /etc/ssh/sshd_config

Encuentra esta línea y cambia el sí por el no de la misma manera que lo hicimos antes con vi.

PermitRootLogin no

Guardar y salir de vi.

Cómo instalar Node.js y Git

Ya podemos continuar e instalar Node.js y Git:

sudo apt install nodejs npm

sudo apt install git

Ahora estamos listos para crear una aplicación Node y ejecutarla. Puedes extraer tu proyecto de Node de Github o crear una aplicación de Node aquí para probar si funciona.

Ves a un directorio de tu elección y crea un archivo "app.js" :

sudo vi app.js

Puedes pegar el siguiente fragmento en tu archivo app.js :

const express = require('express');const app = express();const port = 3000;app.get('/', (req, res) => {        res.send('Hola Mundo');});app.listen(port, () => console.log(`¡Aplicación de ejemplo escuchando en el puerto ${port}!`));

Ahora podemos ejecutarlo con el comando:

node app.js

Deberías ver "¡Aplicación de ejemplo escuchando en el puerto 3000!" en tu terminal.

Podemos confirmar que está funcionando enviando una solicitud a nuestro servidor:

GET http://IP_ADDRESS:3000/

Envía esta solicitud desde un cliente HTTP como Postman o tu navegador y deberías ver el mensaje "Hola Mundo".

En este punto, deberías notar que algo no está bien: Los usuarios regulares no saben cómo enviar solicitudes al puerto 3000.

Deberíamos redirigir las solicitudes que llegan a nuestro servidor web desde nuestra IP al puerto 3000. Esto lo podemos lograr con la ayuda de Nginx.

Cómo instalar y configurar Nginx

Usaremos Nginx como proxy inverso para redirigir las solicitudes a nuestra aplicación Node.

Instalamos Nginx:

sudo apt install nginx

Inicia el servicio Nginx:

sudo service nginx start

Podemos probar para ver si funciona enviando una solicitud a la dirección IP de nuestro servidor desde el navegador. Escribe la dirección IP de tu servidor en tu navegador y deberías ver esto:

Es importante saber que Nginx sirve desde "/var/www/html" de forma predeterminada y también puedes encontrar este archivo HTML en ese directorio.

También te aconsejo que crees una carpeta en "/var/www", llámala app y mueve tu aplicación Node a esa carpeta para que sea fácil de encontrar.

Cómo configurar el proxy inverso de Nginx

Editaremos el archivo de configuración de Nginx para configurar un proxy inverso:

sudo vi /etc/nginx/sites-available/default

En este archivo, debes encontrar la ubicación / block y cambiarla de la siguiente manera:

location / {                # First attempt to serve request as file, then                # as directory, then fall back to displaying a 404.                proxy_pass http://127.0.0.1:3000/;        }

La directivaproxy_pass envía la solicitud a un puerto específico. Damos el puerto en el que se ejecuta nuestra aplicación Node.

Reiniciamos Nginx para que los cambios surtan efecto:

sudo service nginx reload

Después de este paso, deberíamos poder ver el mensaje cuando enviamos una solicitud a nuestro servidor. ¡Felicidades, hemos completado la cantidad mínima de pasos para implementar una aplicación Node!

Pero aún así te aconsejo que completes el siguiente paso también, ya que creo que es bastante importante.

Si no puedes ver el mensaje de hola mundo, puedes verificar si tu aplicación y Nginx se están ejecutando y reiniciarlos.

Cómo ejecutar tu aplicación como un proceso

No queremos iniciar nuestra aplicación manualmente cada vez que algo salga mal y nuestra aplicación falle. Queremos que se reinicie solo. Además, cada vez que se inicia el servidor, nuestra aplicación también debería iniciarse.

Para que esto suceda, podemos usar PM2. Instalemos PM2 y configuremos.

sudo npm i -g pm2

Estamos instalando pm2 globalmente usando la opción "-g" para que sea accesible desde todas las carpetas.

pm2 start app.js

Esto asegura que la aplicación se reinicie si se cierra debido a un error.

Guardemos la lista de procesos actual.

pm2 save

También necesitamos convertirlo en un demonio que se ejecute cada vez que se inicie el sistema:

pm2 startup systemd

Como recordatorio, en este tutorial estoy usando los comandos para Ubuntu. Si estás utilizando cualquier otra distribución de Linux, debes reemplazar systemd en este comando.

Podemos confirmar que el servicio se reinicia reiniciando el servidor y enviando una solicitud sin ejecutar app.js a mano:

sudo reboot

Después de enviar una solicitud como lo hicimos anteriormente, deberías poder ver el mensaje de hola mundo.

Conclusión

En este tutorial, comenzamos desde cero, alquilamos un servidor, nos conectamos y lo configuramos de manera que sirve nuestra aplicación Node.js desde el puerto 80.

Si has seguido y has podido completar todos los pasos, ¡felicidades! Puedes estar orgulloso de ti mismo, ya que este tema no es de lo más fácil :). Espero que hayas aprendido mucho. Gracias por tu tiempo.

Planeo explorar más este tema conectando el servidor a un nombre de dominio y luego conectándolo a CircleCI para una integración continua. También revisaré los pasos necesarios para preparar la producción de tu aplicación Node.js/React. Sin embargo, esta publicación ya se había hecho lo suficientemente larga, por lo que esos temas están reservados para otra publicación :)

Si te ha gustado la lectura y quieres estar informado de mis futuras publicaciones, puedes suscribirte a mi blog personal . Puedes ver mis publicaciones anteriores allí si estás interesado en leer más. Suelo escribir sobre temas relacionados con el desarrollo web.

En este artículo encontrarás una breve introducción al desarrollo web back-end, Node.js y Express. Aprenderás por qué son herramientas muy poderosas para desarrollar servidores y por qué deberías aprenderlos si tu meta es adentrarte en el mundo del desarrollo web back-end.

Luego, encontrarás un curso de 8.5 horas de Node.js y Express en el canal de YouTube de freeCodeCamp en español donde puedes aprender los fundamentos en español y construir un proyecto paso a paso.

¡Comencemos! ✨

🔸 ¿Qué es el desarrollo web back-end?

El desarrollo web ha transformado nuestro mundo. Cada día accedemos a internet para encontrar información, aprender, comprar productos, compartir opiniones y comunicarnos con familiares y amigos.

Básicamente, nuestras vidas no serían lo mismo sin los sitios web.

¿Estás de acuerdo? 🙂

Si estás de acuerdo, entonces aprendiendo desarrollo web puedes desarrollarte en una carrera muy gratificante y puedes impactar las vidas de miles o millones de usuarios desarrollando aplicaciones web.

Hablemos sobre las distintas áreas del desarrollo web.

Desarrollo web front-end vs. desarrollo web back-end

Los desarrolladores que crean estas aplicaciones web asombrosas son llamados desarrolladores web. Pueden especializarse para desarrollar partes específicas de una aplicación web:

• Los desarrolladores web front-end implementan la parte de la aplicación web con la cual los usuarios interactúan directamente. Crean la parte visible de las plataformas asombrosas que usamos cada día. En la analogía de la tienda que puedes ver en la imagen anterior, el front-end estaría representado por la parte de la tienda que los clientes pueden ver.
• Los desarrolladores web back-end implementan toda la funcionalidad que los usuarios no ven, tales como los servidores, bases de datos y todas sus interacciones con el front-end de la aplicación.
• Los desarrolladores web full-stack se encargan de ambas áreas. Tienen conocimiento extenso sobre desarrollo web front-end y back-end.

Interesante, ¿cierto? ✨

Veamos más detalles sobre el desarrollo web back-end porque esta es una de las principales aplicaciones de Node.js y Express.

El modelo cliente-servidor

El internet está basado en el modelo o la arquitectura cliente-servidor, en la cual dos dispositivos (el cliente y el servidor) se comunican entre sí.

El cliente

Cuando intentas acceder a una página web en tu navegador, el navegador (cliente) envía una solicitud HTTP al servidor.

El servidor

El servidor es un programa que escucha solicitudes y genera respuestas apropiadas. Estas respuestas incluyen:

• Enviar información al cliente.
• Ejecutar tareas o procesos.
• Trabajar con la información de una base de datos y/o actualizarla.

Por ejemplo, podemos agregar un usuario nuevo a una base de datos al enviar una solicitud al servidor y el servidor debe realizar las actualizaciones correspondientes en la base de datos.

Desarrollar y mantener servidores es una de las tareas principales de los desarrolladores back-end y esa es precisamente la función principal de Node.js y Express.

🔹 ¿Qué es Node.js?

Node.js es un runtime de JavaScript asíncrono y basado en eventos desarrollado en base al motor V8 de JavaScript de Chrome. Nos da todas las herramientas que necesitamos para ejecutar JavaScript en el terminal sin un navegador web (browser).

💡 Dato: Antes de Node.js, no podíamos ejecutar programas de JavaScript sin un navegador web. Solo los navegadores habían sido diseñados para esta tarea ya que JavaScript es uno de los principales lenguajes de programación de la web.

Lo asombroso de Node.js es que nos permite construir aplicaciones escalables con alto rendimiento.

De acuerdo a su documentación oficial:

Los usuarios de Node.js están libres de preocuparse por el bloqueo del proceso, ya que no existe. Casi ninguna función en Node.js realiza I/O directamente, por lo que el proceso nunca se bloquea. Por ello, es muy propicio desarrollar sistemas escalables en Node.js.

🚩 Es importante resaltar que Node.js no es un:

• Lenguaje de programación.
• Framework.
• Librería (biblioteca).

Es un runtime de JavaScript desarrollado para ejecutar código de JavaScript.

¿Por qué deberías aprender Node.js?

Ahora que ya sabes más sobre Node.js, veamos por qué deberías aprenderlo.

Node.js es una de las tecnologías web más populares entre los desarrolladores, incluyendo principiantes que están aprendiendo a programar y profesionales.

La popularidad de Node.js es asombrosa. De acuerdo a la encuesta 2022 Stack Overflow Developer Survey, es una de las tecnologías web más populares usadas por los que están aprendiendo a programar y por desarrolladores profesionales.

Cuando a los encuestados se les preguntó cuáles frameworks web o tecnologías web habían usado constantemente el año pasado y con cuáles querían trabajar el próximo año, Node.js obtuvo un 47.12% de los votos.

💡 Dato: ¡casi la mitad de las 58,743 respuestas!

Ese porcentaje fue incluso mayor entre los encuestados que estaban aprendiendo a programar:  52.86%. Asombroso, ¿verdad? 😁

Esto demuestra el impacto que Node.js está teniendo en el área del desarrollo web. Al aprender Node.js estarás invirtiendo tu tiempo y recursos sabiamente. Adquirirás habilidades valiosas y altamente demandadas en este campo.

🔸 ¿Qué es Express?

Si tu meta es desarrollar servidores con Node.js, el proceso puede ser mucho más fácil si usas Express, un framework de aplicaciones web específicamente diseñado para Node.js.

Según la documentación oficial de Express:

Express es un framework de aplicaciones web de Node.js mínimo y flexible que provee un conjunto robusto de herramientas para aplicaciones web y móviles.

Original en inglés:

Express is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications.

💡 Dato: Express incluye muchas herramientas que puedes usar para escribir código más conciso, fácil de leer y fácil de mantener. Confía en mi. Cuando comiences a trabajar con Express, nunca querrás dejarlo.

Express tiene muchos métodos HTTP útiles y middleware que puedes usar para crear APIs robustas (Application Programming Interfaces), las cuales son fundamentales para el desarrollo web back-end y full-stack.

En la encuesta 2022 Stack Overflow Developer Survey, Express fue la cuarta tecnología o framework web más usado con 22.99% de los votos:

¡Genial! Ya sabes por qué deberías aprender Node.js y Express. Te prometo que de verdad merecerá tu tiempo y dedicación. ✨

🔹 Contenido del curso

Ahora veamos lo que aprenderás durante el curso.

💡 Dato: para tomar el curso, debes tener conocimiento previo de JavaScript. Si necesitas repasar este lenguaje de programación en español, te recomiendo tomar el curso de JavaScript en el canal de YouTube de freeCodeCamp en español.

Introducción a Node.js y conceptos básicos

• Introducción a Node.js
• Conceptos básicos de desarrollo web back-end.
• Aplicaciones de Node.js
• APIs y para qué se usan.
• Ventajas de Node.js.
• Descargar e instalar Node.js.
• Confirmar que Node.js fue instalado exitosamente.
• Verificar tu versión de Node.js.
• El REPL de Node.js.

Tu primer proyecto de Node.js y módulos

• ¿Qué es un módulo? Conceptos y ventajas.
• Exportar e importar módulos.
• Exportar varios elementos de un módulo de JavaScript.
• Ejecutar un archivo JavaScript con el comando node.
• Módulos core de Node.js.
• El módulo console.
• El módulo process.
• El módulo os.
• El módulo fs.
• El módulo timers.

Introducción a npm y JSON

• ¿Qué es npm?
• Conceptos básicos de npm.
• Inicializar un paquete con npm init.
• El archivo package.json.
• Introducción al formato JSON.
• Instalar y desinstalar paquetes con npm.
• El archivo package-lock.json.

Eventos y operaciones asíncronas

• ¿Qué es un evento?
• Eventos en Node.js.
• Eventos y procesos síncronos y asíncronos.
• Promesas y funciones callback en JavaScript.
• Promesas, .then() y .catch().
• Funciones asíncronas con async y await.

Servidores con Node.js y el protocolo HTTP

• El modelo cliente-servidor.
• Formato de solicitudes y respuestas HTTP.
• Métodos o verbos HTTP:  GET, POST, PUT, DELETE.
• Códigos de estado HTTP.
• El módulo http en Node.js.
• Crear un servidor en Node.js.
• Los objetos req y res.
• Estructura de una URL.
• Routing (Enrutamiento) en Node.js.

Nodemon

• ¿Qué es Nodemon?
• Cómo instalarlo globalmente.
• Cómo usarlo para actualizar aplicaciones de Node.js automáticamente.
• Conceptos importantes: CRUD, REST, API.

Express

• Cómo instalar Express y cómo crear un proyecto.
• Routing en Express.
• Express y Nodemon.
• Cómo manejar varias rutas.
• Parámetros de URL y rutas dinámicas.
• Middleware en Express.
• Manejar solicitudes GET, POST, PUT y DELETE.
• Parámetros query.
• Routers en Express.

🔸 Proyecto de Node.js y Express

Durante el curso aprenderás con ejemplos prácticos, así que aplicarás todo lo que aprendas paso a paso.

Aprenderás cómo trabajar con promesas con un ejemplo de pizza 🍕, cómo trabajar con JavaScript asíncrono, y desarrollarás una API y un servidor básico con Node.js para enviar información sobre cursos de programación y matemáticas al cliente.

Luego, adaptarás este servidor para trabajar con Express. Aplicarás conceptos que has aprendido y aprenderás nuevos conceptos paso a paso para crear un servidor que manejará varias rutas, parámetros y distintos tipos de solicitudes HTTP.

📌 Curso de Node.js y Express en YouTube

Genial. Ahora que ya sabes más sobre Node.js y Express y lo que aprenderás durante el curso, te invito a tomar el curso completo en español:

✍️ Curso creado por Estefania Cassingena Navone (Twitter: @EstefaniaCassN, YouTube: Coding with Estefania).

Sinceramente espero que te guste el curso y que te ayude a tomar tus primeros pasos en el mundo de Node.js, Express y desarrollo web back-end.

También te invitamos a tomar nuestros cursos de programación en español: