La aventura del caché mágico: un cuento del backend

Había una vez, en un reino digital muy lejano, un pequeño servidor llamado Express. Este servidor, aunque valiente, se enfrentaba a un gran reto: cada vez que recibía una petición, tenía que realizar una operación muy compleja y lenta, como si tuviera que cruzar un puente colgante en medio de una tormenta. La gente del reino se impacientaba al esperar dos largos segundos por cada respuesta, y el servidor, exhausto, soñaba con encontrar una solución que lo hiciera más ágil y eficiente.

Un día, mientras deambulaba por la biblioteca de los códigos antiguos, Express encontró un pergamino que hablaba de un hechizo legendario: la caché. Según contaba la leyenda, este hechizo permitía almacenar los resultados de operaciones costosas en una cajita mágica, de manera que, si se solicitaba la misma información nuevamente, el resultado se entregaría en un abrir y cerrar de ojos, sin tener que volver a recorrer el peligroso puente.

Intrigado y esperanzado, Express decidió embarcarse en una aventura para dominar este hechizo y transformar su destino.

Te invito a acompañarlo en esta travesía, donde aprenderás paso a paso cómo implementar la magia de la caché usando TypeScript, Express y Redis.

Preparando el terreno: el castillo de código

Antes de que Express pueda invocar cualquier hechizo, es necesario construir el castillo de código. Sigue estos pasos para preparar el entorno:

1. Crea el directorio del proyecto

Abre la terminal y escribe:

mkdir cache-magic
cd cache-magic

2. Inicializa el proyecto con npm

Esto creará la bitácora del castillo, un archivo misterioso llamado package.json:

npm init -y

3. Instala las dependencias

Asumamos que express será el puente que une a los habitantes del reino, redis la cajita mágica, y typescript el lenguaje encantado para escribir con precisión. Los demás secuaces ts-node, @types/node y @types/express ayudan a que el conjuro escrito pueda hacerse realidad.

npm install express redis
npm install -D typescript ts-node @types/node @types/express

4. Configura TypeScript

Crea un archivo llamado tsconfig.json en la raíz del proyecto y pega la siguiente configuración, que asegurará que tu código se compile adecuadamente:

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./",
    "strict": true,
    "esModuleInterop": true
  }
}

Adicional, en el package.json agrega el siguiente script:

{
...
  "script": {
    "start": "ts-node server.ts"
  }
...
}

Despertando la cajita mágica

Para almacenar los resultados de las operaciones costosas, Express necesitaba la ayuda de un aliado poderoso: Redis. Este guardián de la caché vive en un contenedor mágico que se puede invocar fácilmente usando Docker. Abre la terminal y ejecuta el siguiente conjuro:

docker run --name redis-cache -p 6379:6379 -d redis

Con este comando, Docker descarga y despierta a Redis, quien estará listo para guardar los hechizos de caché en el puerto 6379.

El ritual del código

Ya con el castillo y la cajita mágica preparados, llegó el momento de que Express aprendiera a usar la caché. Abre el directorio con tu editor de código favorito y crea un archivo llamado server.ts. En él, escribe el siguiente código, que narra la aventura de dos caminos muy distintos:

import { createClient } from "redis";
import express from "express";

const app = express();
const port = 3000;

// Conectamos con la cajita mágica: Redis
const redisClient = createClient();
redisClient.on("error", (err) => console.error("Error en Redis:", err));
redisClient.connect().then(() => console.log("¡Redis ha despertado!"));

// Este es el hechizo que simula una operación costosa, como cruzar el puente en medio de la tormenta.
function expensiveOperation(): Promise<string> {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(`Resultado mágico: ${Math.random()}`);
    }, 2000); // 2 segundos para simular el desafío
  });
}

// El camino sin atajos: cada petición realiza la operación costosa de nuevo.
app.get("/without-cache", async (req, res) => {
  const result = await expensiveOperation();
  res.send(result);
});

// El camino con la magia de la caché: consulta primero la cajita mágica (Redis)
app.get("/with-cache", async (req, res) => {
  const cacheKey = "expensiveResult";
  const cachedResult = await redisClient.get(cacheKey);
  if (cachedResult) {
    res.send(`Desde la caché: ${cachedResult}`);
    return;
  }
  const result = await expensiveOperation();
  // Se guarda el resultado en la cajita mágica con una duración de 1 hora
  await redisClient.set(cacheKey, result, { EX: 3600 });
  res.send(`Computado y guardado: ${result}`);
});

// El hechizo final: iniciamos el servidor para que escuche a los habitantes del reino.
app.listen(port, () => {
  console.log(`El servidor está en marcha en http://localhost:${port}`);
});

La historia detrás del código

En esta historia, Express se enfrenta a dos desafíos:

El camino sin caché (/without-cache)

Cada vez que un ciudadano solicita información, Express debe cruzar el puente y realizar la operación compleja, lo que le toma 2 segundos. La espera se acumula, y el cansancio es evidente.

El camino con caché (/with-cache)

Aquí, Express actúa con astucia. Antes de cruzar el puente, consulta a la cajita mágica, Redis. Si el resultado ya está almacenado, lo entrega al instante. Solo si el resultado no se encuentra en la cajita, Express cruza el puente, realiza la operación y guarda el resultado para futuras peticiones, ahorrándose así tiempo y esfuerzo.

Poniendo en marcha la aventura

Con el código escrito y Redis corriendo, es hora de ver la magia en acción.

1. Ejecuta la API:

Usa el siguiente comando poner a prueba el hechizo:

npm start

2. Prueba los caminos:

Abre tu navegador o una herramienta como curl y visita:

• http://localhost:3000/without-cache

Aquí verás que cada petición tarda 2 segundos en responder, ya que el puente se cruza siempre.

• http://localhost:3000/with-cache

La primera petición tardará 2 segundos y guardará el resultado en la cajita mágica. Las peticiones posteriores, realizadas en la próxima hora (3600 segundos), se resolverán casi instantáneamente.

El final de la aventura

Gracias a la magia de la caché, Express logró transformar su destino. La operación costosa se ejecuta solo cuando es necesario, y la cajita mágica (Redis) se encarga de entregar los resultados almacenados a velocidad de vértigo. Con esto, el servidor aligeró su carga, los ciudadanos del reino recibieron respuestas más rápidas y, en definitiva, se ahorraron valiosos recursos.

Así concluye nuestra aventura en el reino del backend. Con unos pocos pasos —desde la creación del proyecto, la instalación de dependencias, el levantamiento de Redis, hasta la implementación del código— espero que hayas aprendido a conjurar la magia de la caché para optimizar tu API.

¡Ahora es tu turno de llevar este hechizo a tus propios proyectos y obtener tiempos de respuesta sorprendentes!