Cache em JavaScript (Node.js): Redis e outras soluções |…

Cache em JavaScript (Node.js): Redis e outras ferramentas

Cache é uma das formas mais eficazes de melhorar o desempenho de aplicações web em Node.js. Permite reduzir o tempo de resposta, diminuir a carga nos bancos de dados e reduzir custos de infraestrutura. Neste artigo, abordaremos as principais ferramentas de cache no ambiente Node.js: Redis, Memcached e cache em memória interna (in-memory cache). Você aprenderá quando escolher cada ferramenta e verá exemplos práticos de código.

Por que usar cache em Node.js?

Node.js é single-threaded, mas assíncrono. Cada requisição ao banco de dados ou API externa é uma espera (I/O). O cache permite salvar o resultado de uma operação custosa (como uma consulta SQL complexa ou parsing de HTML) e entregá-lo instantaneamente. Principais casos de uso:

Salvar resultados de consultas ao BD (especialmente agregadas)
Cache de respostas de APIs externas (clima, taxas de câmbio)
Armazenamento de sessões de usuários
Armazenamento temporário de dados computados (ex.: renderização de templates)

1. Redis — o rei do cache

Redis é um armazenamento de dados in-memory frequentemente usado como cache. Ele roda em um processo separado, suporta estruturas de dados complexas (strings, hashes, listas, conjuntos) e possui mecanismos integrados de TTL (tempo de vida da chave).

Instalação e conexão

Para funcionar, é necessário um servidor Redis instalado (localmente ou em Docker). No Node.js, usamos o pacote redis:

npm install redis

Exemplo: cache de dados com TTL

const redis = require('redis');const client = redis.createClient();

client.on('error', (err) => console.error('Erro no Redis:', err));

// Função assíncrona para obter dados com cacheasync function getCachedData(key, fetchFunction, ttlSeconds = 60) {  // Tenta obter do cache  const cached = await client.get(key);  if (cached) {    return JSON.parse(cached);  }

  // Se não existe — chama a função custosa  const freshData = await fetchFunction();

  // Salva no cache com TTL  await client.setEx(key, ttlSeconds, JSON.stringify(freshData));  return freshData;}

// Uso: cache do resultado de uma consulta ao BDconst users = await getCachedData('users:list', () => db.query('SELECT * FROM users'), 120);

Vantagens do Redis

Alta performance (milhões de operações por segundo)
Suporte a TTL, pub/sub, transações
Persistência (pode salvar em disco)
Adequado para sistemas distribuídos (vários servidores Node.js)

Desvantagens

Requer um servidor/container separado
Consome memória RAM
Excessivo para aplicações single-thread simples

2. Memcached — leve e rápido

Memcached é outro cache in-memory popular, mas mais simples que o Redis: apenas strings, sem persistência, sem estruturas complexas. Ideal para cache simples de dados.

Instalação e exemplo

npm install memcached

const Memcached = require('memcached');const memcached = new Memcached('localhost:11211');

async function getCachedData(key, fetchFunction, ttlSeconds = 60) {  return new Promise((resolve, reject) => {    memcached.get(key, async (err, data) => {      if (data) return resolve(JSON.parse(data));

      const freshData = await fetchFunction();      memcached.set(key, JSON.stringify(freshData), ttlSeconds, (err) => {        if (err) reject(err);        resolve(freshData);      });    });  });}