Tutorial de microservicios con Node.js para principiantes

Introducción

Node.js se ha convertido en una de las plataformas más populares para el desarrollo de aplicaciones web. Permite a los desarrolladores usar JavaScript no solo en el navegador, sino también en el servidor. Si alguna vez has pensado en crear aplicaciones completas usando un solo lenguaje, ¡este es el lugar indicado para comenzar!

Este tutorial está pensado para aquellos que ya tienen conocimientos básicos de JavaScript y desean dar sus primeros pasos en el desarrollo de aplicaciones web con Node.js. Partiremos desde lo más básico, como la instalación de Node.js, hasta la creación de un servidor simple. A lo largo de este camino, también cubriremos los fundamentos necesarios sobre HTTP, REST y otras bases del desarrollo web. Además, añadiremos algunas prácticas avanzadas para profundizar más en el uso de Node.js y construir aplicaciones robustas.

Requerimientos previos

Para sacar el máximo provecho de este tutorial, necesitas algunos conocimientos previos:

• JavaScript: Para seguir este tutorial, deberías tener un nivel básico-intermedio de JavaScript. Es recomendable que te sientas cómodo con conceptos como funciones, objetos, arrays, promesas y el uso de async/await. Si necesitas un repaso, te sugerimos familiarizarte con estos conceptos antes de seguir adelante.
• Bases de Programación: Tener experiencia general en programación (en cualquier lenguaje) será de gran ayuda. Si ya comprendes cómo funcionan los bucles, las variables, las estructuras de control y la lógica de programación, estarás listo para empezar con Node.js.
• Editor de Código: Usaremos Visual Studio Code (VS Code) como editor para este tutorial. Puedes descargarlo de forma gratuita y lo usaremos debido a su popularidad y facilidad de uso.
• Conceptos Web: Este tutorial está orientado a aquellos que desean desarrollar aplicaciones web. Conocer conceptos como HTTP, peticiones (GET, POST), RESTful APIs, y cómo funcionan los servidores será importante, y cubriremos una introducción a estos conceptos a medida que avancemos.

Instalación de Node.js en Windows

Primero, necesitamos instalar Node.js en tu sistema. Node.js incluye npm, el gestor de paquetes que nos permitirá instalar bibliotecas y herramientas adicionales.

1. Descargar Node.js: Dirígete a https://nodejs.org y descarga la versión recomendada para tu sistema operativo Windows.
2. Instalación: Ejecuta el instalador y sigue las instrucciones, asegurándote de marcar la opción que dice «Agregar Node.js al PATH» durante la instalación.
3. Verificar la instalación: Abre el terminal de Windows (puedes buscar «cmd» en el menú de inicio) y escribe:

   node -v
   npm -v

Esto debería mostrarte la versión instalada de Node.js y npm. Si todo está correcto, estarás listo para continuar.

Primeros pasos con Node.js: «Hola, mundo» en el servidor

Vamos a crear nuestro primer servidor utilizando Node.js. Esto nos ayudará a entender los conceptos básicos de cómo funciona un servidor y cómo podemos usar JavaScript para manejar peticiones HTTP.

1. Crear una carpeta para tu proyecto:
   Crea una nueva carpeta en tu sistema, por ejemplo, node-hola-mundo. Abre Visual Studio Code y selecciona «Abrir carpeta» para trabajar en ella.
2. Inicializar el proyecto:
   Abre el terminal dentro de Visual Studio Code (puedes hacerlo con Ctrl + ñ) y escribe:

   npm init -y

Este comando creará un archivo package.json, que nos permitirá gestionar las dependencias y configuraciones de nuestro proyecto.

3. Escribir el código del servidor:
   Crea un archivo llamado server.js dentro de la carpeta del proyecto. Abre este archivo y agrega el siguiente código:

   const http = require('http');

   const hostname = '127.0.0.1';
   const port = 3000;

   const server = http.createServer((req, res) => {
     res.statusCode = 200;
     res.setHeader('Content-Type', 'text/plain');
     res.end('Hola, mundo!\n');
   });

   server.listen(port, hostname, () => {
     console.log(`Servidor corriendo en http://${hostname}:${port}/`);
   });

4. Ejecutar el servidor:
   En el terminal, escribe:

   node server.js

Deberías ver un mensaje que dice «Servidor corriendo en http://127.0.0.1:3000/«. Abre tu navegador y visita esa dirección para ver tu mensaje «Hola, mundo!».

Explicando el código

• Módulo http: Utilizamos el módulo http incorporado en Node.js para crear un servidor. Esto nos permite manejar peticiones HTTP y enviar respuestas.
• createServer: Este método crea un servidor que manejará cada petición con una función callback. En nuestro caso, simplemente estamos enviando un mensaje de texto como respuesta.
• listen: Esto indica al servidor que escuche en un puerto específico (en nuestro caso, el 3000) y en una dirección IP específica (a menudo localhost o 127.0.0.1).

Introducción a npm y módulos

Node.js se vuelve extremadamente poderoso cuando comienzas a usar paquetes externos. npm (Node Package Manager) te permite instalar estos paquetes con facilidad. Por ejemplo, uno de los módulos más populares para crear servidores web en Node.js es Express.

Para instalar Express, escribe en el terminal:

npm install express

Creando un servidor con Express

Express simplifica el proceso de crear un servidor y manejar rutas. Vamos a ver cómo podemos crear un servidor similar al anterior usando Express:

1. Crear el archivo app.js: En lugar de server.js, vamos a crear un archivo llamado app.js.
2. Agregar código con Express:

   const express = require('express');
   const app = express();
   const port = 3000;

   app.get('/', (req, res) => {
     res.send('Hola, mundo con Express!');
   });

   app.listen(port, () => {
     console.log(`Servidor Express corriendo en http://localhost:${port}`);
   });

3. Ejecutar el servidor:
   Nuevamente, en el terminal escribe:

   node app.js

Ahora, al visitar http://localhost:3000/, verás el mensaje «Hola, mundo con Express!».

Entendiendo las peticiones HTTP

HTTP (HyperText Transfer Protocol) es el protocolo básico que permite la comunicación entre un cliente (como tu navegador) y un servidor (como el que acabamos de crear). Las peticiones HTTP son mensajes que envían los clientes para solicitar datos o realizar acciones en el servidor.

• GET: Se utiliza para solicitar datos. Por ejemplo, cuando visitas una URL en tu navegador, estás haciendo una petición GET.
• POST: Se utiliza para enviar datos al servidor. Por ejemplo, cuando envías un formulario en una página web.

Express hace que manejar estos métodos sea extremadamente sencillo. Ya hemos visto un ejemplo de GET con app.get('/'). Para manejar una petición POST, podríamos hacer lo siguiente:

app.post('/datos', (req, res) => {
  res.send('Datos recibidos!');
});

Middleware y rutas

Express permite manejar diferentes rutas y también agregar lógica intermedia, conocida como middleware, que se ejecuta antes de llegar a la función de respuesta final. Por ejemplo, podríamos agregar un middleware para registrar cada petición que llega a nuestro servidor:

app.use((req, res, next) => {
  console.log(`Petición recibida: ${req.method} ${req.url}`);
  next();
});

El middleware es muy poderoso y nos permite extender la funcionalidad del servidor de maneras únicas, como autenticar usuarios, gestionar errores, etc.

Rutas dinámicas y parámetros en Express

Uno de los beneficios de usar Express es la posibilidad de manejar rutas dinámicas y parámetros. Esto nos permite crear URLs que puedan cambiar de acuerdo a los datos que envíen los usuarios. Por ejemplo, podríamos crear una ruta que salude a diferentes usuarios:

app.get('/saludar/:nombre', (req, res) => {
  const nombre = req.params.nombre;
  res.send(`Hola, ${nombre}!`);
});

En este ejemplo, si visitas http://localhost:3000/saludar/Jordi, el servidor responderá con «Hola, Jordi!».

Trabajando con JSON en Node.js

Las aplicaciones modernas a menudo necesitan enviar y recibir datos en formato JSON. Express facilita el manejo de JSON con su middleware incorporado. Veamos un ejemplo:

1. Primero, necesitamos decirle a nuestra aplicación que use el middleware express.json() para que pueda interpretar el cuerpo de las peticiones en formato JSON:

app.use(express.json());

2. Luego, podemos manejar una petición POST que reciba datos en JSON:

app.post('/usuario', (req, res) => {
  const usuario = req.body;
  res.send(`Usuario recibido: ${usuario.nombre}`);
});

Si enviamos una petición POST a /usuario con un JSON que tenga {"nombre": "Jordi"}, el servidor responderá con «Usuario recibido: Jordi».

Conectando Node.js a una base de datos

Conectar Node.js a una base de datos es el siguiente paso para crear aplicaciones web completas. Para este tutorial, utilizaremos MongoDB, una base de datos NoSQL que se integra muy bien con Node.js. Utilizaremos el cliente Mongoose para gestionar la comunicación con MongoDB.

1. Instalar MongoDB y Mongoose:

npm install mongoose

2. Conectar a MongoDB:

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mi_base_de_datos', {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => console.log('Conectado a MongoDB'))
.catch(err => console.error('Error al conectar a MongoDB', err));

Creando un esquema y modelo con Mongoose

En MongoDB, los datos se organizan en colecciones y documentos. Utilizaremos Mongoose para definir un esquema y un modelo:

const UsuarioSchema = new mongoose.Schema({
  nombre: String,
  edad: Number
});

const Usuario = mongoose.model('Usuario', UsuarioSchema);

CRUD: Crear, Leer, Actualizar y Borrar

Mongoose nos permite realizar las operaciones CRUD sobre la base de datos con gran facilidad. Veamos algunos ejemplos:

• Crear un usuario:

const nuevoUsuario = new Usuario({ nombre: 'Jordi', edad: 30 });
nuevoUsuario.save()
  .then(usuario => console.log('Usuario guardado:', usuario))
  .catch(err => console.error('Error al guardar usuario:', err));

• Leer usuarios:

Usuario.find()
  .then(usuarios => console.log('Usuarios encontrados:', usuarios))
  .catch(err => console.error('Error al encontrar usuarios:', err));

• Actualizar un usuario:

Usuario.updateOne({ nombre: 'Jordi' }, { edad: 31 })
  .then(result => console.log('Usuario actualizado:', result))
  .catch(err => console.error('Error al actualizar usuario:', err));

• Borrar un usuario:

Usuario.deleteOne({ nombre: 'Jordi' })
  .then(result => console.log('Usuario borrado:', result))
  .catch(err => console.error('Error al borrar usuario:', err));

Desplegando tu aplicación en la nube

Una vez que has desarrollado tu aplicación, el siguiente paso es desplegarla en la nube para que pueda ser accesible públicamente. Existen diferentes servicios que permiten desplegar aplicaciones Node.js de manera fácil, como Heroku o Vercel. A continuación, te explicamos cómo desplegar tu aplicación en Heroku.

1. Instalar Heroku CLI: Para poder desplegar en Heroku, necesitas instalar su línea de comandos. Dirígete a https://devcenter.heroku.com/articles/heroku-cli y sigue las instrucciones para la instalación.
2. Crear una cuenta en Heroku: Si aún no tienes una cuenta en Heroku, regístrate en https://signup.heroku.com/.
3. Iniciar sesión en Heroku desde la terminal:

heroku login

4. Inicializar un repositorio git: Heroku utiliza git para el despliegue. Inicializa un repositorio git en la carpeta de tu proyecto:

git init
git add .
git commit -m "Primer commit"

5. Crear una aplicación en Heroku:

heroku create nombre-de-tu-aplicacion

6. Desplegar la aplicación:

git push heroku master

Una vez completado, tu aplicación estará disponible en la URL que Heroku te proporcionará.

Implementar autenticación de usuarios

En una aplicación real, la autenticación de usuarios es una parte crucial. La autenticación asegura que solo los usuarios autorizados puedan acceder a ciertas partes de tu aplicación. Vamos a implementar una autenticación básica utilizando JWT (JSON Web Tokens) y la librería bcrypt para encriptar contraseñas.

1. Instalar JWT y bcrypt:

npm install jsonwebtoken bcrypt

2. Crear usuarios con contraseñas encriptadas:

const bcrypt = require('bcrypt');

app.post('/register', async (req, res) => {
  try {
    const hashedPassword = await bcrypt.hash(req.body.password, 10);
    const nuevoUsuario = new Usuario({
      nombre: req.body.nombre,
      edad: req.body.edad,
      password: hashedPassword
    });
    await nuevoUsuario.save();
    res.status(201).send('Usuario creado con éxito');
  } catch (err) {
    res.status(500).send('Error al crear el usuario');
  }
});

3. Generar y verificar JWT:

const jwt = require('jsonwebtoken');

app.post('/login', async (req, res) => {
  try {
    const usuario = await Usuario.findOne({ nombre: req.body.nombre });
    if (!usuario) return res.status(404).send('Usuario no encontrado');

    const match = await bcrypt.compare(req.body.password, usuario.password);
    if (!match) return res.status(401).send('Contraseña incorrecta');

    const token = jwt.sign({ id: usuario._id }, 'secreto', { expiresIn: '1h' });
    res.json({ token });
  } catch (err) {
    res.status(500).send('Error en el proceso de autenticación');
  }
});

Optimización del rendimiento y buenas prácticas de seguridad

• Usar Helmet: Helmet es un middleware que ayuda a proteger tu aplicación al configurar varios encabezados HTTP relacionados con la seguridad. Para instalar Helmet:

npm install helmet

const helmet = require('helmet');
app.use(helmet());

• Evitar datos sensibles en el código: Utiliza variables de entorno para gestionar datos sensibles como contraseñas y claves API. Puedes utilizar la librería dotenv para cargar estas variables desde un archivo .env:

npm install dotenv

require('dotenv').config();

Creando una RESTful API

Una API RESTful permite que diferentes aplicaciones se comuniquen entre sí. Vamos a crear una API básica para gestionar usuarios.

1. Definir las rutas para la API:

app.get('/api/usuarios', async (req, res) => {
  try {
    const usuarios = await Usuario.find();
    res.json(usuarios);
  } catch (err) {
    res.status(500).send('Error al obtener los usuarios');
  }
});

app.post('/api/usuarios', async (req, res) => {
  try {
    const nuevoUsuario = new Usuario(req.body);
    await nuevoUsuario.save();
    res.status(201).json(nuevoUsuario);
  } catch (err) {
    res.status(400).send('Error al crear el usuario');
  }
});

2. Probando la API: Puedes utilizar herramientas como Postman o Insomnia para probar tus endpoints y asegurarte de que todo funciona correctamente.

Próximos pasos y mantente al tanto

En este tutorial, hemos cubierto los conceptos básicos de Node.js, la creación de un servidor, conexión a bases de datos, despliegue en la nube, autenticación de usuarios, y la creación de una RESTful API. Hemos visto cómo puedes usar Node.js y Express para crear aplicaciones modernas y escalables.

Node.js y Express son herramientas muy potentes que te permitirán desarrollar aplicaciones completas y eficientes. La clave está en la práctica constante y la experimentación, así que sigue construyendo, aprendiendo y explorando nuevas funcionalidades.

¡No olvides visitar regularmente nuestra web para nuevos tutoriales y recursos que te ayudarán a seguir avanzando en tu camino como desarrollador Node.js! ¡Nos vemos en el próximo tutorial y sigue explorando y desarrollando tus habilidades cada fin de semana!