Cache em JavaScript: Redis, Memcached e soluções integradas (nível avançado)

Cache em JavaScript: Redis, Memcached e soluções integradas (nível avançado)

No desenvolvimento web moderno, o desempenho da aplicação muitas vezes depende da velocidade de acesso aos dados. Cada consulta extra ao banco de dados ou API externa aumenta o tempo de resposta e a carga no servidor. O cache não é apenas "salvar o resultado", mas toda uma ciência que envolve a escolha da estratégia, ferramenta e mecanismo de invalidação corretos. Neste artigo, abordaremos técnicas avançadas de cache em Node.js: desde soluções integradas até sistemas industriais como Redis e Memcached.

1. Cache integrado em Node.js: simplicidade e limitações

Antes de conectar serviços externos, vale a pena avaliar os recursos do próprio Node.js. O cache integrado é implementado usando objetos Map ou WeakMap, bem como variáveis globais simples. Isso é ideal para dados que raramente mudam e vivem dentro de um único processo.

// Cache simples em memória com TTL (Time To Live)class MemoryCache {  constructor(ttl = 60000) {    this.cache = new Map();    this.ttl = ttl;  }

  set(key, value) {    this.cache.set(key, {      value,      expiry: Date.now() + this.ttl    });  }

  get(key) {    const item = this.cache.get(key);    if (!item) return null;    if (Date.now() > item.expiry) {      this.cache.delete(key);      return null;    }    return item.value;  }

  delete(key) {    this.cache.delete(key);  }

  clear() {    this.cache.clear();  }}

// Usoconst cache = new MemoryCache(30000); // 30 segundos de TTLcache.set('user:42', { name: 'Alice', role: 'admin' });console.log(cache.get('user:42')); // { name: 'Alice', role: 'admin' }

Vantagens: latência de rede zero, simplicidade de implementação, não requer dependências externas.
Desvantagens: os dados são perdidos ao reiniciar o processo, não escala para vários servidores, limitado pela memória RAM de um único nó.

Para microsserviços que rodam em um único processo, ou para armazenar em cache resultados de cálculos pesados (por exemplo, renderização de templates), a solução integrada é uma excelente escolha. No entanto, para sistemas distribuídos, ela não é suficiente.

2. Redis: o rei do cache em Node.js

Redis é um armazenamento de dados in-memory frequentemente usado como cache de alto desempenho. Suas principais vantagens: suporte a estruturas de dados complexas (strings, listas, conjuntos, hashes), TTL integrado, pub/sub e persistência em disco.

Conectando Redis no Node.js

Para trabalhar com Redis no Node.js, usa-se o pacote ioredis (recomendado) ou redis. Vejamos um exemplo com ioredis:

const Redis = require('ioredis');

const redis = new Redis({  host: 'localhost',  port: 6379,  retryStrategy: (times) => Math.min(times * 50, 2000) // estratégia de reconexão});

// Operações básicasawait redis.set('mykey', 'Hello, Redis!', 'EX', 60); // TTL de 60 segundosconst value = await redis.get('mykey');console.log(value); // "Hello, Redis!"

// Usando hash para armazenar objetos complexosawait redis.hmset('user:100', {  name: 'Bob',  email: 'bob@example.com',  age: 30});const user = await redis.hgetall('user:100');console.log(user); // { name: 'Bob', email: 'bob@example.com', age: '30' }

Estratégias avançadas com Redis

Cache-Aside (Lazy Loading): a aplicação primeiro verifica o cache e, somente em caso de falta, consulta o banco de dados e preenche o cache.

async function getUser(userId) {  const cacheKey = `user:${userId}`;  let user = await redis.get(cacheKey);  if (user) {    return JSON.parse(user);  }  // Falta no cache — carrega do banco de dados  user = await db.findUserById(userId);  if (user) {    await redis.set(cacheKey, JSON.stringify(user), 'EX', 3600); // cache por 1 hora  }  ret