Guía Práctica: Cómo Implementar Autenticación en Node.js con Facilidad

Introducción

La autenticación es un aspecto crucial en el desarrollo de aplicaciones web y APIs, ya que garantiza la seguridad de los usuarios y protege la información sensible. En este artículo, aprenderás a implementar autenticación en Node.js de manera sencilla utilizando JSON Web Tokens (JWT), bcrypt para encriptar contraseñas y Express.js como framework principal.

Configuración del Entorno

Antes de comenzar, asegúrate de tener Node.js instalado. Luego, crea un nuevo proyecto e instala las dependencias necesarias:

mkdir auth-nodejs && cd auth-nodejs
npm init -y
npm install express bcryptjs jsonwebtoken dotenv cors mongoose

Explicación de las dependencias:

• express: Framework para manejar rutas y peticiones.

• bcryptjs: Para encriptar contraseñas.

• jsonwebtoken: Para generar y verificar tokens de autenticación.

• dotenv: Para manejar variables de entorno.

• cors: Para permitir peticiones desde diferentes dominios.

• mongoose: Para interactuar con una base de datos MongoDB.

Configuración del Servidor Express

Crea un archivo server.js y configura un servidor básico:

const express = require('express');
const mongoose = require('mongoose');
const dotenv = require('dotenv');
const cors = require('cors');

dotenv.config();
const app = express();
app.use(express.json());
app.use(cors());

mongoose.connect(process.env.MONGO_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true
}).then(() => console.log('MongoDB conectado'))
  .catch(err => console.error(err));

app.listen(5000, () => console.log('Servidor corriendo en el puerto 5000'));

Creación del Modelo de Usuario

Define un modelo para almacenar los usuarios en la base de datos MongoDB.

const mongoose = require('mongoose'); const UserSchema = new mongoose.Schema({ username: { type: String, required: true, unique: true }, email: { type: String, required: true, unique: true }, password: { type: String, required: true } }); module.exports = mongoose.model('User', UserSchema);

Registro de Usuarios con Encriptación

Crea una ruta para registrar usuarios y almacenar contraseñas encriptadas con bcryptjs.

const express = require('express');
const bcrypt = require('bcryptjs');
const User = require('../models/User');

const router = express.Router();

router.post('/register', async (req, res) => {
  try {
    const { username, email, password } = req.body;
    const salt = await bcrypt.genSalt(10);
    const hashedPassword = await bcrypt.hash(password, salt);
    
    const newUser = new User({ username, email, password: hashedPassword });
    await newUser.save();
    res.status(201).json({ message: 'Usuario registrado exitosamente' });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

module.exports = router;

Autenticación con JSON Web Tokens (JWT)

Ahora, implementemos el login y la generación de un token JWT:

const jwt = require('jsonwebtoken');
router.post('/login', async (req, res) => {
  try {
    const { email, password } = req.body;
    const user = await User.findOne({ email });
    if (!user) return res.status(404).json({ message: 'Usuario no encontrado' });
    
    const isMatch = await bcrypt.compare(password, user.password);
    if (!isMatch) return res.status(400).json({ message: 'Contraseña incorrecta' });
    
    const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '1h' });
    res.json({ token });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

Middleware para Proteger Rutas

Para proteger rutas que solo usuarios autenticados pueden acceder, creamos un middleware de autenticación.

const authMiddleware = (req, res, next) => {
  const token = req.header('Authorization');
  if (!token) return res.status(401).json({ message: 'Acceso denegado' });
  
  try {
    const verified = jwt.verify(token, process.env.JWT_SECRET);
    req.user = verified;
    next();
  } catch (error) {
    res.status(400).json({ message: 'Token inválido' });
  }
};

module.exports = authMiddleware;

Implementación de Rutas Protegidas

Creamos una ruta privada que solo puede ser accedida con un token válido.

router.get('/profile', authMiddleware, async (req, res) => {
  const user = await User.findById(req.user.id).select('-password');
  res.json(user);
});

Conclusión

Implementar autenticación en Node.js es un paso fundamental para asegurar la seguridad en aplicaciones web. En esta guía, hemos visto cómo configurar el entorno, crear un sistema de autenticación con bcryptjs para encriptación y JWT para la gestión de sesiones. Ahora puedes extender esta implementación con roles de usuario, autenticación con OAuth o integración con terceros.

¡Empieza a proteger tu aplicación hoy mismo, o si prefieres puedes contactarnos en GrowMyBiss para que podamos ayudarte! 🚀