O que é Redis e para que serve

Quando uma página demora porque cada acesso consulta o banco, o problema quase nunca é o banco ser ruim. É que o mesmo dado é lido milhares de vezes. O Redis nasceu para isso: guardar na memória o que é lido o tempo todo e devolver quase sem espera.

Hoje ele vai além do cache. Segundo a documentação oficial, é um armazenamento em memória usado como cache, banco de documentos, banco vetorial, motor de streaming e message broker.

O que é Redis?#

Redis é um servidor de estruturas de dados que mantém o conjunto de dados na memória RAM. Você conecta por rede, manda comandos como SET e GET e recebe a resposta. O projeto de código aberto existe desde 2009.

O modelo básico é chave-valor: cada dado tem uma chave (texto) e um valor. A diferença para um dicionário comum é que o valor pode ser uma estrutura inteira (lista, conjunto, hash) e que o servidor entende essas estruturas, com operações atômicas sobre elas.

Por que o Redis é tão rápido?#

O motivo principal é a memória. Ler da RAM é muito mais rápido do que ler de disco, e o Redis mantém o conjunto de dados lá. O acesso também é direto pela chave, sem planejamento de consulta nem joins, e os comandos são simples e específicos para cada estrutura.

O preço dessa velocidade é a capacidade: a RAM custa mais por gigabyte do que o disco, então o conjunto de dados do Redis precisa caber na memória que você contratou.

Quais estruturas de dados o Redis tem?#

O Redis Open Source oferece, entre outros, estes tipos:

• Strings: sequência de bytes. Serve para texto, JSON serializado e contadores.
• Hashes: pares campo-valor, como um objeto com propriedades.
• Listas: listas de strings na ordem de inserção, boas para filas simples.
• Conjuntos (sets): strings únicas e sem ordem, com teste de pertencimento em O(1).
• Conjuntos ordenados (sorted sets): strings únicas ordenadas por uma pontuação, ideais para rankings.
• Streams: um log de eventos em que só se acrescenta, para processar eventos na ordem em que ocorreram.
• Outros: bitmaps, índices geoespaciais, HyperLogLog, JSON, séries temporais e conjuntos vetoriais.

Toda chave pode ter um tempo de vida (TTL). Quando o prazo acaba, o Redis apaga a chave sozinho. É assim que um cache se limpa e que uma sessão expira.

Para que o Redis serve na prática?#

Os usos mais comuns:

• Cache: guardar o resultado de uma consulta lenta ou de uma chamada de API por alguns segundos ou minutos.
• Sessões: manter a sessão do usuário num lugar que vários processos da aplicação consigam ler.
• Contadores e limite de requisições: INCR incrementa um número de forma atômica, o que resolve contagem de acessos e rate limit.
• Rankings: um sorted set mantém a pontuação ordenada sem você reordenar nada.
• Filas e pub/sub: listas, streams e canais de publicação passam trabalho ou mensagens entre processos.
• Bots: guardar cooldowns, configurações por servidor ou estado temporário de comandos.

Exemplo: cache de consulta em Node.js#

O código abaixo usa o node-redis (instale com npm install redis) e o padrão cache-aside: tenta o cache e, se não achar, busca na fonte e grava com TTL de 60 segundos. A URL de conexão fica numa variável de ambiente.

import { createClient } from "redis";

const redis = createClient({ url: process.env.REDIS_URL });
redis.on("error", (err) => console.error("Redis Client Error", err));
await redis.connect();

// Simula uma consulta lenta ao banco principal
async function loadUserFromDatabase(id) {
  await new Promise((resolve) => setTimeout(resolve, 300));
  return { id, name: "Ada" };
}

async function getUser(id) {
  const key = `user:${id}`;

  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached); // cache hit

  const user = await loadUserFromDatabase(id); // cache miss
  await redis.set(key, JSON.stringify(user), {
    expiration: { type: "EX", value: 60 },
  });
  return user;
}

console.log(await getUser(1)); // ~300 ms
console.log(await getUser(1)); // vem do Redis
await redis.quit();

Defina REDIS_URL no formato redis://usuario:senha@host:6379 (ou rediss:// quando o servidor exige TLS). Salve o arquivo como cache.mjs e rode com node cache.mjs: a primeira chamada leva cerca de 300 ms, e a segunda vem direto do Redis. Repare na convenção tipo:id (user:1) nas chaves: o Redis não tem namespaces, e a documentação recomenda esse padrão.

Os dados do Redis sobrevivem a um reinício?#

Sobrevivem, se você ativar a persistência. O Redis tem duas formas, que podem ser combinadas:

• RDB: grava fotografias do conjunto de dados em intervalos (por exemplo, save 60 1000 grava a cada 60 segundos se ao menos 1000 chaves mudaram). É compacto e reinicia rápido, mas um desligamento inesperado pode perder os últimos minutos.
• AOF (append-only file): registra cada escrita e as reaplica ao subir. Com appendonly yes e a política padrão appendfsync everysec, você perde no máximo cerca de um segundo de escritas.

Também é possível desligar a persistência, o que é comum quando o Redis é só cache. A documentação sugere usar RDB e AOF juntos se você quer um nível de segurança de dados comparável ao do PostgreSQL.

O que acontece quando a memória enche?#

Você define um limite com maxmemory (por exemplo, maxmemory 100mb). Ao atingi-lo, o Redis segue a política maxmemory-policy. Com noeviction, ele recusa novas escritas e devolve erro. Com allkeys-lru, ele apaga as chaves menos usadas recentemente, que é um bom padrão para cache. Existem ainda variações volatile-*, que só removem chaves com TTL.

É aqui que cache e banco se separam: num cache, apagar chave antiga é o comportamento desejado. Para dados que não podem sumir, use noeviction e monitore o uso.

Quando não usar o Redis?#

• Dados grandes e relacionais: se o conjunto não cabe na RAM ou você precisa de joins, consultas ad hoc e restrições, um banco como o PostgreSQL é mais adequado. Veja também como escolher um banco de dados.
• Documentos com consultas flexíveis: o MongoDB foi feito para isso.
• Dados críticos sem persistência: numa configuração de cache sem persistência, um reinício apaga tudo.
• Varrer todas as chaves: o comando KEYS bloqueia o servidor em bases grandes. Use SCAN, que itera aos poucos.

Um arranjo comum é usar o Redis ao lado de um banco principal: o banco guarda a verdade e o Redis acelera as leituras. Para decidir onde rodar o banco, leia como hospedar um banco de dados.

Redis ou Valkey?#

O Valkey é um projeto BSD apoiado pela Linux Foundation que inclui código do Redis licenciado em BSD. Já o Redis Open Source, a partir da versão 8, é oferecido sob RSALv2, SSPLv1 ou AGPLv3, à sua escolha. Leia a licença se você pretende redistribuir ou revender o software e confira a compatibilidade com a versão e os módulos que você usa.

Como fazer isso na Square Cloud#

O exemplo de cache acima roda, mudando só a conexão, na hospedagem de Redis da Square Cloud, disponível a partir do plano Standard (de R$ 44,99 por mês); o Hobby não inclui bancos. Você cria o Redis no painel, sempre numa versão recente, e escolhe a memória a partir de 512 MB, tirada da RAM do plano. Como o conjunto de dados precisa caber nessa memória, dimensione pelo que os seus dados ocupam, com folga. O banco fica pronto em segundos no mesmo datacenter das suas aplicações, com latência média de cerca de 1 ms.

A conexão exige TLS: a URL do painel começa com rediss://, e o cliente precisa confiar na CA do certificado que você baixa ali (no node-redis, passe o arquivo em socket.ca). Guarde a URL em REDIS_URL, a mesma variável do exemplo. Há um único database lógico, então a convenção tipo:id nas chaves é o que separa cache, sessões e filas. Clientes ociosos são desconectados após 5 minutos: o node-redis reconecta sozinho, mas confira esse comportamento se usar outro cliente.

O Redis hospedado tem persistência e aceita PUBLISH/SUBSCRIBE, o que cobre sessões, contadores e pub/sub além do cache. Você tira snapshots manuais quando quiser, e todo plano com bancos faz também um snapshot automático diário, que restaura no mesmo banco, em outro Redis ou num banco novo.

Veja os detalhes e crie a instância em Hospedagem de Redis.