Tutorial completo para crear una API RESTful con Node.js y Express
En este tutorial aprenderás a construir una API RESTful con Node.js y el framework Express. Está dirigido a desarrolladores de nivel intermedio que quieran fortalecer sus habilidades en el desarrollo backend y crear servicios web robustos conectados a bases de datos MongoDB, además de implementar autenticación básica.
Este tutorial cubre desde la instalación del entorno, configuración del proyecto, creación de rutas, manejo de peticiones HTTP, conexión con MongoDB, hasta la implementación de un sistema sencillo de autenticación.
Índice
- Introducción y requisitos
- Configuración del entorno y proyecto
- Estructura básica de una API con Express
- Creación de rutas y manejo de peticiones HTTP
- Conexión con MongoDB usando Mongoose
- Implementación de autenticación básica
- Buenas prácticas y conclusión
Introducción y requisitos
Antes de empezar, asegúrate de tener instalados los siguientes componentes en tu sistema:
- Node.js (v14 o superior recomendado)
- npm (administrador de paquetes de Node.js)
- MongoDB (puede ser local o un servicio en la nube como MongoDB Atlas)
Este tutorial está enfocado en el uso de JavaScript moderno (ES6+) y herramientas comunes para el desarrollo backend.
Configuración del entorno y proyecto
1. Crear carpeta y proyecto Node.js
Abre una terminal y ejecuta:
|
1 2 3 4 |
mkdir mi-api-express cd mi-api-express npm init -y |
Esto crea un proyecto básico con un archivo package.json.
2. Instalar dependencias necesarias
Vamos a instalar Express para el servidor, Mongoose para conectar con MongoDB, y otras utilidades:
|
1 2 |
npm install express mongoose dotenv bcryptjs jsonwebtoken |
dotenv: carga variables de entorno desde un archivo.envbcryptjs: para encriptar contraseñasjsonwebtoken: para generar tokens JWT
Opcionalmente, instala nodemon para desarrollo:
|
1 2 |
npm install --save-dev nodemon |
Y configura en package.json el script de inicio:
|
1 2 3 4 5 |
"scripts": { "start": "node index.js", "dev": "nodemon index.js" } |
Estructura básica de una API con Express
Crea el archivo index.js como punto de entrada del servidor:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
const express = require('express'); const app = express(); const PORT = process.env.PORT || 3000; // Middleware para parsear JSON app.use(express.json()); // Ruta raíz app.get('/', (req, res) => { res.send('API RESTful con Node.js y Express funcionando'); }); // Iniciar servidor app.listen(PORT, () => { console.log(`Servidor escuchando en puerto ${PORT}`); }); |
Ejecuta con:
|
1 2 |
npm run dev |
Abre en tu navegador o con una herramienta como Postman http://localhost:3000/ y verás el mensaje.
Creación de rutas y manejo de peticiones HTTP
Una API RESTful consta de rutas que responden a diferentes métodos HTTP (GET, POST, PUT, DELETE).
1. Crear carpeta para rutas
Organiza el código creando carpeta /routes y un archivo users.js:
|
1 2 |
mkdir routes |
routes/users.js:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
const express = require('express'); const router = express.Router(); // GET /users - obtener todos los usuarios router.get('/', (req, res) => { res.json({ message: 'Obtener todos los usuarios' }); }); // POST /users - crear nuevo usuario router.post('/', (req, res) => { const { name, email } = req.body; // Aquí va lógica para crear usuario... res.json({ message: `Usuario ${name} creado con email ${email}` }); }); module.exports = router; |
2. Importar y usar las rutas en index.js
Modifica para que tu API use las rutas:
|
1 2 3 4 |
const usersRouter = require('./routes/users'); app.use('/users', usersRouter); |
Con esto, GET /users y POST /users estarán disponibles.
Conexión con MongoDB usando Mongoose
1. Configura variables de entorno
Crea archivo .env con:
|
1 2 3 4 |
PORT=3000 MONGO_URI=mongodb://localhost:27017/miapinode JWT_SECRET=mi_clave_secreta |
2. Configura conexión a MongoDB en index.js
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
require('dotenv').config(); const mongoose = require('mongoose'); mongoose.connect(process.env.MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true }) .then(() => console.log('Conectado a MongoDB')) .catch(err => { console.error('Error conexión MongoDB:', err.message); process.exit(1); }); |
3. Crear modelo de usuario con Mongoose
En carpeta /models crea User.js:
|
1 2 3 4 5 6 7 8 9 10 |
const mongoose = require('mongoose'); const userSchema = new mongoose.Schema({ name: { type: String, required: true }, email: { type: String, required: true, unique: true }, password: { type: String, required: true }, }, { timestamps: true }); module.exports = mongoose.model('User', userSchema); |
4. Actualizar ruta POST /users para guardar usuario
En routes/users.js, importa User y bcryptjs para encriptar la contraseña:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
const User = require('../models/User'); const bcrypt = require('bcryptjs'); router.post('/', async (req, res) => { try { const { name, email, password } = req.body; // Validar datos if (!name || !email || !password) { return res.status(400).json({ message: 'Faltan datos obligatorios' }); } // Verificar si usuario ya existe const userExist = await User.findOne({ email }); if (userExist) { return res.status(409).json({ message: 'Usuario ya existe' }); } // Encriptar contraseña const salt = await bcrypt.genSalt(10); const hashedPassword = await bcrypt.hash(password, salt); // Crear usuario const newUser = new User({ name, email, password: hashedPassword }); await newUser.save(); res.status(201).json({ message: 'Usuario creado exitosamente' }); } catch (error) { console.error(error); res.status(500).json({ message: 'Error en el servidor' }); } }); |
Implementación de autenticación básica
Implementaremos un sistema de login que retorna un JWT para autenticar peticiones posteriores.
1. Crear ruta de autenticación /routes/auth.js
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
const express = require('express'); const router = express.Router(); const User = require('../models/User'); const bcrypt = require('bcryptjs'); const jwt = require('jsonwebtoken'); router.post('/login', async (req, res) => { try { const { email, password } = req.body; if (!email || !password) { return res.status(400).json({ message: 'Faltan email o contraseña' }); } const user = await User.findOne({ email }); 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' }); } // Generar token JWT const token = jwt.sign( { id: user._id, email: user.email }, process.env.JWT_SECRET, { expiresIn: '1h' } ); res.json({ token }); } catch (error) { console.error(error); res.status(500).json({ message: 'Error en el servidor' }); } }); module.exports = router; |
2. Usar ruta de autenticación en index.js
|
1 2 3 |
const authRouter = require('./routes/auth'); app.use('/auth', authRouter); |
3. Crear middleware para validar token JWT
Crea archivo /middlewares/auth.js:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
const jwt = require('jsonwebtoken'); function authMiddleware(req, res, next) { const authHeader = req.headers.authorization; if (!authHeader || !authHeader.startsWith('Bearer ')) { return res.status(401).json({ message: 'No autorizado' }); } const token = authHeader.split(' ')[1]; try { const decoded = jwt.verify(token, process.env.JWT_SECRET); req.user = decoded; // guardar datos del usuario next(); } catch (error) { return res.status(401).json({ message: 'Token inválido' }); } } module.exports = authMiddleware; |
4. Proteger rutas con middleware
Por ejemplo, en routes/users.js protege la ruta GET /users:
|
1 2 3 4 5 6 7 8 |
const authMiddleware = require('../middlewares/auth'); // Ruta protegida router.get('/', authMiddleware, async (req, res) => { const users = await User.find().select('-password'); res.json(users); }); |
Buenas prácticas y recomendaciones
- Usa variables de entorno para gestionar configuraciones sensibles (MongoDB URI, claves).
- Estructura modular: separa rutas, modelos, controladores y middlewares.
- Manejo de errores adecuado: responde con códigos HTTP y mensajes claros.
- Validación de datos: considera usar paquetes como
Joioexpress-validator. - Prueba y documenta tu API usando Postman o Swagger.
Conclusión
Con este tutorial has aprendido a crear una API RESTful con Node.js y Express, conectarte a MongoDB con Mongoose, manejar rutas y peticiones HTTP, y añadir autenticación básica con JWT.
Próximos pasos recomendados:
- Extender autenticación con roles y permisos.
- Implementar paginación y filtros para consultas.
- Configurar despliegue en plataformas como Heroku o Vercel.
¡Empieza a implementar tu backend siguiendo este tutorial y mejora tus habilidades en desarrollo APIs RESTful!
Código ejemplo para iniciar el servidor (index.js completo):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
require('dotenv').config(); const express = require('express'); const mongoose = require('mongoose'); const usersRouter = require('./routes/users'); const authRouter = require('./routes/auth'); const app = express(); const PORT = process.env.PORT || 3000; app.use(express.json()); // Conexión a MongoDB mongoose.connect(process.env.MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true }).then(() => console.log('Conectado a MongoDB')) .catch(err => { console.error('Error conexión MongoDB:', err.message); process.exit(1); }); app.get('/', (req, res) => { res.send('API RESTful con Node.js y Express funcionando'); }); app.use('/users', usersRouter); app.use('/auth', authRouter); app.listen(PORT, () => { console.log(`Servidor escuchando en puerto ${PORT}`); }); |
