Tutorial Node: Módulo http

Qué es el módulo http

El módulo http es uno de los módulos principales de Node.js que permite crear servidores y clientes HTTP de forma nativa, sin necesidad de instalar dependencias externas. Este módulo forma parte del núcleo de Node.js y proporciona las herramientas fundamentales para construir aplicaciones web y APIs.

A diferencia de JavaScript en el navegador, donde las peticiones HTTP se realizan principalmente a través de fetch() o XMLHttpRequest, Node.js nos permite tanto realizar peticiones HTTP como crear servidores que respondan a estas peticiones. El módulo http actúa como la base sobre la cual se construyen la mayoría de frameworks web de Node.js.

Importación y uso básico

Para utilizar el módulo http, debemos importarlo usando la función require(), ya que es un módulo nativo que viene incluido con Node.js:

const http = require('http');

Una vez importado, tenemos acceso a métodos como createServer(), request(), y get(), que nos permiten crear servidores HTTP y realizar peticiones a otros servicios.

Creación de un servidor HTTP básico

El caso de uso más común del módulo http es la creación de servidores web. Un servidor HTTP básico se crea utilizando el método createServer():

const http = require('http');

// Crear el servidor
const servidor = http.createServer((peticion, respuesta) => {
  // Configurar el tipo de contenido
  respuesta.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  
  // Enviar la respuesta
  respuesta.end('¡Hola desde Node.js!');
});

// Hacer que el servidor escuche en el puerto 3000
servidor.listen(3000, () => {
  console.log('Servidor ejecutándose en http://localhost:3000');
});

En este ejemplo, createServer() recibe una función callback que se ejecuta cada vez que el servidor recibe una petición. Esta función recibe dos parámetros: el objeto peticion (request) y el objeto respuesta (response).

Objetos request y response

El módulo http proporciona dos objetos fundamentales para manejar la comunicación HTTP:

El objeto peticion (request) contiene toda la información sobre la petición entrante:

const servidor = http.createServer((peticion, respuesta) => {
  console.log('Método HTTP:', peticion.method);
  console.log('URL solicitada:', peticion.url);
  console.log('Headers:', peticion.headers);
  
  respuesta.writeHead(200, { 'Content-Type': 'text/plain' });
  respuesta.end(`Recibida petición ${peticion.method} a ${peticion.url}`);
});

El objeto respuesta (response) nos permite configurar y enviar la respuesta al cliente:

const servidor = http.createServer((peticion, respuesta) => {
  // Configurar código de estado y headers
  respuesta.writeHead(200, {
    'Content-Type': 'application/json',
    'Access-Control-Allow-Origin': '*'
  });
  
  // Enviar datos JSON
  const datos = { mensaje: 'Respuesta desde Node.js', timestamp: Date.now() };
  respuesta.end(JSON.stringify(datos));
});

Manejo de diferentes rutas

Un servidor HTTP real necesita manejar diferentes rutas. Podemos implementar un sistema básico de enrutamiento utilizando la propiedad url del objeto petición:

const http = require('http');
const url = require('url');

const servidor = http.createServer((peticion, respuesta) => {
  const rutaParsed = url.parse(peticion.url, true);
  const ruta = rutaParsed.pathname;
  
  respuesta.writeHead(200, { 'Content-Type': 'application/json' });
  
  if (ruta === '/') {
    respuesta.end(JSON.stringify({ mensaje: 'Página principal' }));
  } else if (ruta === '/usuarios') {
    respuesta.end(JSON.stringify({ usuarios: ['Ana', 'Carlos', 'María'] }));
  } else if (ruta === '/productos') {
    respuesta.end(JSON.stringify({ productos: ['Laptop', 'Mouse', 'Teclado'] }));
  } else {
    respuesta.writeHead(404);
    respuesta.end(JSON.stringify({ error: 'Ruta no encontrada' }));
  }
});

servidor.listen(3000);

Realizar peticiones HTTP como cliente

El módulo http también permite que Node.js actúe como cliente HTTP, realizando peticiones a otros servidores:

const http = require('http');

// Configuración de la petición
const opciones = {
  hostname: 'jsonplaceholder.typicode.com',
  port: 80,
  path: '/posts/1',
  method: 'GET'
};

// Realizar la petición
const peticion = http.request(opciones, (respuesta) => {
  let datos = '';
  
  // Recibir datos por chunks
  respuesta.on('data', (chunk) => {
    datos += chunk;
  });
  
  // Procesar respuesta completa
  respuesta.on('end', () => {
    console.log('Respuesta recibida:', JSON.parse(datos));
  });
});

// Manejar errores
peticion.on('error', (error) => {
  console.error('Error en la petición:', error);
});

// Enviar la petición
peticion.end();

Para peticiones GET simples, Node.js proporciona el método http.get() como atajo:

http.get('http://jsonplaceholder.typicode.com/posts/1', (respuesta) => {
  let datos = '';
  
  respuesta.on('data', (chunk) => datos += chunk);
  respuesta.on('end', () => {
    console.log('Post obtenido:', JSON.parse(datos));
  });
}).on('error', (error) => {
  console.error('Error:', error);
});

Características del módulo http nativo

El módulo http de Node.js es minimalista por diseño. Proporciona las funcionalidades básicas para trabajar con HTTP, pero requiere que implementemos manualmente muchas características que consideramos estándar en el desarrollo web moderno:

• Enrutamiento manual: Debemos parsear las URLs y implementar la lógica de enrutamiento
• Parsing de datos: Los datos del cuerpo de las peticiones llegan como streams que debemos procesar
• Gestión de middleware: No existe un sistema de middleware integrado
• Manejo de cookies: Debemos implementar la lógica para leer y escribir cookies
• Parsing de formularios: El procesamiento de datos de formularios requiere implementación manual

Esta aproximación minimalista hace que el módulo http sea muy eficiente y nos dé control total sobre el comportamiento del servidor, pero también significa que necesitamos escribir más código para funcionalidades comunes.

Diferencia entre módulo http nativo y framework express

Al desarrollar aplicaciones web en Node.js, es habitual encontrar referencias tanto al módulo http nativo como a frameworks como Express. Aunque ambos permiten crear servidores web, existen diferencias clave en su enfoque, nivel de abstracción y experiencia de desarrollo.

El módulo http nativo es la base fundamental para la comunicación HTTP en Node.js. Proporciona una interfaz de bajo nivel que nos da control directo sobre cada aspecto de la petición y la respuesta. Esto implica que, como desarrolladores, debemos encargarnos manualmente de tareas como el enrutamiento, el procesamiento del cuerpo de la petición, la gestión de cabeceras y la respuesta a diferentes tipos de solicitudes.

Por ejemplo, para manejar rutas y procesar datos en el módulo http, es necesario analizar la URL y los datos recibidos de forma explícita, como se muestra en este fragmento:

const http = require('http');

const servidor = http.createServer((req, res) => {
  if (req.method === 'GET' && req.url === '/saludo') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('¡Hola!');
  } else {
    res.writeHead(404);
    res.end('No encontrado');
  }
});

servidor.listen(3000);

En este ejemplo, toda la lógica de enrutamiento y respuesta se implementa manualmente, lo que otorga flexibilidad total pero también requiere mayor esfuerzo y atención a los detalles.

Por otro lado, Express es un framework que se construye sobre el módulo http nativo y proporciona una capa de abstracción más alta. Express incluye utilidades para el enrutamiento, el procesamiento de datos del cuerpo de la petición, la gestión de middleware y otras tareas comunes en el desarrollo web. Esto permite escribir código más conciso y legible, delegando en el framework la gestión de muchos aspectos repetitivos.

A modo de comparación conceptual, el flujo de trabajo con cada enfoque puede representarse así:

• Con módulo http nativo:

• Control total sobre cada petición y respuesta.

• Implementación manual de rutas, parsing de datos y gestión de errores.

• Mayor esfuerzo inicial, pero máxima flexibilidad.

• Con Express:

• Abstracción de tareas comunes mediante métodos y utilidades integradas.

• Definición de rutas y middlewares de forma declarativa.

• Menor cantidad de código para tareas habituales, pero menos control sobre los detalles internos.

Un diagrama conceptual sencillo para visualizar la relación sería:

[Cliente HTTP] → [Servidor Node.js (http nativo)] → [Lógica personalizada]
[Cliente HTTP] → [Servidor Node.js (Express)] → [Middleware Express] → [Lógica personalizada]

En el primer caso, el desarrollador implementa todo el flujo; en el segundo, Express gestiona gran parte del proceso y permite centrarse en la lógica de negocio.

En resumen, la diferencia principal radica en el nivel de abstracción y la cantidad de código que el desarrollador debe escribir. El módulo http nativo es ideal para quienes buscan control absoluto y aprendizaje profundo de los fundamentos de Node.js, mientras que Express está orientado a la productividad y la rapidez en el desarrollo de aplicaciones web, facilitando tareas repetitivas y estructurando el código de manera más organizada. En este curso, nos centraremos exclusivamente en el uso del módulo http nativo para comprender a fondo cómo funciona Node.js sin depender de frameworks externos.