Servidor HTTP con Express en Node.js

Crear un servidor HTTP con Express (desde cero)

Express es un framework minimalista que se ejecuta sobre Node.js y simplifica la creación de servidores HTTP. En esta sección vas a levantar un servidor funcional, definir un puerto, arrancarlo y comprobar que responde con una ruta de salud (health check).

1) Instanciar la aplicación

El servidor en Express comienza creando una instancia de la app. Normalmente se hace en un archivo de entrada (por ejemplo, server.js o index.js).

const express = require('express');

const app = express();

app representa tu servidor: sobre él registrarás middlewares (funciones que procesan la petición) y rutas (endpoints).

2) Configurar el puerto

El puerto es el “canal” donde tu servidor escucha peticiones. En backend es habitual permitir que el entorno lo defina (por ejemplo, en despliegue) y tener un valor por defecto en local.

const PORT = process.env.PORT || 3000;

3) Middleware esencial: parsing de JSON

Si tu backend va a recibir cuerpos JSON (lo más común en APIs), necesitas habilitar el parser. Express incluye express.json() para convertir el body de la petición en un objeto JavaScript disponible en req.body.

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

app.use(express.json());

Sin este middleware, en peticiones como POST con JSON, req.body podría venir undefined.

4) CORS y cabeceras básicas (según necesidad)

Si tu frontend (por ejemplo, en http://localhost:5173) consume tu API (por ejemplo, en http://localhost:3000), el navegador aplicará la política de mismo origen y necesitarás CORS. En backend, la forma más práctica es usar el middleware cors. Configúralo de forma restrictiva cuando sepas qué orígenes deben acceder.

const cors = require('cors');

app.use(cors({
  origin: ['http://localhost:5173'],
  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization']
}));

Si tu API es pública o estás en fase de pruebas, podrías permitir cualquier origen, pero en producción conviene limitarlo:

app.use(cors());

Además de CORS, a veces interesa añadir cabeceras básicas para identificar el tipo de respuesta. Express lo hace automáticamente cuando envías JSON con res.json() (establece Content-Type: application/json).

5) Ruta de salud (health check)

Un health check es un endpoint simple para verificar que el servidor está vivo y respondiendo. Suele ser un GET /health que devuelve un JSON pequeño.

app.get('/health', (req, res) => {
  res.status(200).json({ status: 'ok' });
});

Esto es útil tanto para ti (pruebas rápidas) como para sistemas de despliegue o balanceadores que validan el estado del servicio.

6) Arrancar el servidor

Para empezar a escuchar peticiones HTTP, usa app.listen. Recibe el puerto y un callback opcional para confirmar el arranque.

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

Ejemplo completo mínimo (servidor listo)

Este ejemplo integra instanciación, JSON parsing, CORS y health check:

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

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware: parsear JSON
app.use(express.json());

// Middleware: CORS (ajusta origin segn tu caso)
app.use(cors({
  origin: ['http://localhost:5173'],
  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization']
}));

// Health check
app.get('/health', (req, res) => {
  res.status(200).json({ status: 'ok', uptime: process.uptime() });
});

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

Verificación rápida del health check

Una vez arrancado el servidor, puedes comprobarlo desde el navegador visitando http://localhost:3000/health o con una petición HTTP desde terminal:

curl http://localhost:3000/health

Deberías recibir un JSON similar a:

{"status":"ok","uptime":12.345}

Entender el ciclo Request/Response

Cuando un cliente (navegador, app móvil, otro servidor) hace una petición HTTP, ocurre este flujo:

• El cliente envía una request (método, URL, cabeceras y opcionalmente body).
• Express recibe la request y la procesa en orden: primero los middlewares (app.use), luego la ruta que coincida (app.get, app.post, etc.).
• Tu código construye una response (status, cabeceras, body) y la envía con res.

En Express, la función de una ruta suele tener esta forma:

app.get('/ruta', (req, res) => {
  // leer req
  // construir y enviar res
});

El objeto req (request)

req contiene la información de entrada. Propiedades comunes:

• req.method: método HTTP (GET, POST, etc.).
• req.path: ruta solicitada.
• req.params: parámetros de ruta (por ejemplo, /users/:id).
• req.query: query string (por ejemplo, ?page=2).
• req.headers: cabeceras.
• req.body: cuerpo parseado (requiere express.json() para JSON).

Ejemplo con query:

app.get('/echo', (req, res) => {
  res.json({ query: req.query });
});

Si llamas /echo?name=ana, responderá {"query":{"name":"ana"}}.

El objeto res (response)

res se usa para devolver la respuesta al cliente. Métodos típicos:

• res.status(code): define el código HTTP (200, 201, 400, 404, 500...).
• res.json(obj): envía JSON y ajusta cabeceras.
• res.send(texto|buffer|obj): envía contenido (si pasas un objeto, Express puede serializarlo, pero para APIs es preferible res.json).
• res.set(header, value): establece cabeceras.

Ejemplo de respuesta JSON con status:

app.get('/api/info', (req, res) => {
  res.status(200).json({
    name: 'mi-api',
    version: '1.0.0'
  });
});

Ejemplo práctico: endpoint que recibe JSON

Este ejemplo muestra por qué express.json() es esencial. Crea un endpoint POST /api/echo que devuelve lo que recibe:

app.post('/api/echo', (req, res) => {
  // req.body contiene el JSON parseado
  res.status(200).json({ received: req.body });
});

Prueba con:

curl -X POST http://localhost:3000/api/echo \
  -H "Content-Type: application/json" \
  -d '{"message":"hola"}'

Respuesta esperada:

{"received":{"message":"hola"}}

Orden de middlewares y rutas (detalle importante)

Express procesa en el orden en que registras app.use y app.get/post. Por eso, el parser JSON y CORS suelen ir arriba, antes de las rutas. Si registras una ruta antes de express.json(), esa ruta no verá req.body parseado.