Cómo Implementar Autenticación con JWT en una Aplicación Backend

En el desarrollo web, garantizar la autenticación y seguridad de las aplicaciones es una prioridad. JSON Web Tokens (JWT) es una solución moderna, eficiente y ampliamente utilizada para autenticar usuarios y proteger endpoints. En este tutorial, exploraremos cómo implementar JWT en una aplicación backend utilizando Node.js y Express.

Requisitos Previos

• Conocimientos básicos de JavaScript.
• Node.js y npm instalados en tu sistema.
• Familiaridad con Express.

Paso 1: Configurar un Proyecto Node.js

1. Crea una carpeta para tu proyecto y accede a ella:

   bash
   
   mkdir jwt-auth-backend
   cd jwt-auth-backend
   

2. Inicializa un proyecto Node.js:

   bash
   npm init -y
   

3. Instala las dependencias necesarias:

   bash
   npm install express body-parser jsonwebtoken dotenv bcryptjs

Paso 2: Crear la Estructura del Proyecto

Organiza tu proyecto de esta forma:

bash

jwt-auth-backend/
├── node_modules/
├── .env
├── server.js
├── routes/
│   └── auth.js
├── controllers/
│   └── authController.js
└── models/
    └── userModel.js

Paso 3: Configurar el Archivo .env

Crea un archivo .env para almacenar las claves secretas:

env

PORT=5000
JWT_SECRET=tu_clave_secreta

Paso 4: Implementar el Modelo de Usuario

En models/userModel.js, crea un modelo básico de usuario usando una estructura ficticia:

javascript

const users = []; // Array para almacenar usuarios temporalmente.

module.exports = {
  users,
};

Paso 5: Crear el Controlador de Autenticación

En controllers/authController.js:

javascript

const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const { users } = require('../models/userModel');

exports.register = async (req, res) => {
  const { username, password } = req.body;

  if (!username || !password) {
    return res.status(400).json({ message: 'Todos los campos son obligatorios' });
  }

  const hashedPassword = await bcrypt.hash(password, 10);
  users.push({ username, password: hashedPassword });

  res.status(201).json({ message: 'Usuario registrado exitosamente' });
};

exports.login = async (req, res) => {
  const { username, password } = req.body;

  const user = users.find(u => u.username === username);
  if (!user) {
    return res.status(401).json({ message: 'Credenciales inválidas' });
  }

  const isMatch = await bcrypt.compare(password, user.password);
  if (!isMatch) {
    return res.status(401).json({ message: 'Credenciales inválidas' });
  }

  const token = jwt.sign({ username }, process.env.JWT_SECRET, { expiresIn: '1h' });
  res.json({ token });
};

Paso 6: Crear las Rutas de Autenticación

En routes/auth.js:

javascript

const express = require('express');
const { register, login } = require('../controllers/authController');
const router = express.Router();

router.post('/register', register);
router.post('/login', login);

module.exports = router;

Paso 7: Configurar el Servidor

En server.js:

javascript

const express = require('express');
const bodyParser = require('body-parser');
const dotenv = require('dotenv');
const authRoutes = require('./routes/auth');

dotenv.config();

const app = express();

app.use(bodyParser.json());
app.use('/api/auth', authRoutes);

const PORT = process.env.PORT || 5000;
app.listen(PORT, () => console.log(`Servidor corriendo en el puerto ${PORT}`));

Paso 8: Proteger Rutas con JWT

Añade un middleware para verificar los tokens:

javascript

const jwt = require('jsonwebtoken');

exports.verifyToken = (req, res, next) => {
  const token = req.headers['authorization'];

  if (!token) {
    return res.status(403).json({ message: 'Se requiere un token' });
  }

  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(401).json({ message: 'Token inválido' });
    }
    req.user = user;
    next();
  });
};

Paso 9: Probar la Implementación

1. Registra un usuario enviando una solicitud POST a /api/auth/register con el cuerpo:

   json
   
   {
     "username": "usuario",
     "password": "contraseña"
   }
   

2. Inicia sesión enviando una solicitud POST a /api/auth/login. Obtendrás un token en la respuesta.
3. Utiliza el token para acceder a rutas protegidas añadiéndolo en los encabezados de la solicitud.

¿Buscas ayuda para desarrollar tu API?

Implementar autenticación con JWT en un backend no solo es sencillo, sino que también proporciona una capa de seguridad fundamental para las aplicaciones modernas. Si necesitas un sitio web seguro, funcional y con el mejor diseño, contáctanos en www.sitesupremacy.com.

¡Empieza hoy!