Se você está começando no mundo da programação e já ouviu alguém comentar sobre “colocar no Redis”, talvez tenha ficado com aquela dúvida: afinal, o que é esse tal de Redis e por que todo mundo parece amar essa ferramenta? 😅
Calma, porque hoje a gente vai simplificar tudo isso — como se fosse uma conversa de dev pra dev, sem complicar nada.

O Redis é um banco de dados super rápido baseado em memória, usado para guardar informações que precisam ser acessadas com velocidade absurda — tipo cache, sessões de usuários, filas de processamento e até rate limiting em APIs. E não é brincadeira não: grandes empresas como Twitter, GitHub, StackOverflow, Uber e muitas outras usam Redis para garantir desempenho. Então, sim… vale muito a pena entender como essa ferramenta funciona e como integrar com projetos modernos como os feitos com NestJS.

Neste artigo, você vai aprender:

• Para que serve o Redis e por que ele é tão rápido
• Como ele funciona por baixo dos panos
• Situações reais em que vale a pena usar Redis
• Exemplos práticos integrando NestJS + Redis
• Boas práticas para usar Redis como cache, fila e store de sessão

Tudo explicado de forma direta, leve e simples — perfeito para quem está começando, mas também útil para quem já programa e quer entender melhor esse super aliado da performance.

🔥 Não perca! Clique aqui e participe do canal do CulturaDev no WhatsApp para receber vagas de emprego, artigos, notícias, tendências e muito mais.

O que é Redis e para que ele serve?

Antes de colocar a mão na massa, precisamos entender de forma simples o que exatamente é o Redis. Imagine um banco de dados, mas muito mais rápido do que os que você normalmente usa. Agora imagine que, em vez de salvar as informações em disco, ele guarda tudo diretamente na memória RAM — e é exatamente aí que a mágica acontece.

O Redis (sigla para Remote Dictionary Server) é um banco de dados NoSQL baseado em chave-valor, projetado para ser extremamente rápido, leve e eficiente. Ele é ideal para cenários onde você precisa acessar informações quase instantaneamente, como:

• Cache de requisições
• Armazenamento de sessões de usuários
• Contadores e estatísticas em tempo real
• Filas de processamento (queues)
• Rate limiting (limitar requisições)

E o mais interessante: o Redis suporta vários tipos de dados além de simples strings — como listas, conjuntos, hashes, streams e sorted sets — tornando-o muito mais versátil do que parece à primeira vista.

Em resumo:

O Redis é seu melhor amigo quando o assunto é velocidade.
Ele não substitui seu banco principal, mas turbina sua aplicação onde importa: performance.

Como o Redis funciona por baixo dos panos?

Agora que você já sabe o que é o Redis, vale entender por que ele é tão rápido — e esse é um daqueles conhecimentos que realmente fazem diferença quando você precisa justificar decisões técnicas no trabalho ou em entrevistas.

O segredo está em três pontos principais:

1. Tudo acontece na memória RAM

Ao contrário de bancos tradicionais, que gravam e leem dados do disco, o Redis trabalha diretamente na RAM. Isso faz com que operações como salvar, buscar e atualizar aconteçam em microssegundos.

2. Um único thread bem otimizado

Pode parecer estranho, mas o Redis roda em apenas uma thread. Isso evita problemas clássicos como locks, concorrência e disputas de escrita, tornando tudo mais previsível e rápido. Ele simplesmente processa tudo na ordem que chega — e faz isso absurdamente bem.

3. Estruturas de dados otimizadas

O Redis não usa tabelas tradicionais. Em vez disso, ele utiliza estruturas de dados pensadas para velocidade:

• Strings para valores simples
• Hashes para objetos
• Lists para filas
• Sets para coleções únicas
• Sorted Sets para rankings
• Streams para eventos em tempo real

Cada estrutura é altamente otimizada para operações específicas, garantindo performance mesmo com alto volume de dados.

Mas e se a RAM acabar?

Boa pergunta! O Redis pode persistir dados no disco periodicamente, ou salvar apenas quando necessário. Assim, mesmo sendo baseado em memória, ele não perde tudo caso o servidor reinicie.

Quando usar o Redis na vida real? (Cenários que realmente fazem diferença)

Agora que você já entendeu como o Redis funciona, vamos para a parte que mais interessa: quando vale a pena usar Redis no seu projeto?
Porque, sinceramente, nem sempre ele é necessário — mas quando é, ele pode transformar a performance da sua aplicação de forma absurda.

Aqui vão os cenários mais comuns (e úteis) do dia a dia:

1. Cache de consultas lentas

Essa é a aplicação mais famosa.
Sabe aquela consulta pesada no banco, tipo um SELECT que demora vários segundos?
Em vez de rodar tudo de novo, você salva o resultado no Redis e busca de lá em milésimos.

Perfeito para:

• APIs públicas
• Dados que mudam pouco
• Dashboards
• Sistemas de catálogo (produtos, imóveis, etc.)

2. Armazenamento de sessões

Aplicações com login frequentemente precisam guardar:

• ID do usuário
• Token de sessão
• Preferências

Colocar isso no Redis é comum porque:

• É rápido
• Fácil de escalar
• Funciona bem com múltiplas instâncias da aplicação

É o famoso “session store”.

3. Filas de mensagens (Jobs)

Se você usa filas como:

• enviar e-mails
• processar imagens
• gerar PDFs
• rodar tarefas pesadas em segundo plano

Pode usar Redis como “motor” da fila.
Ferramentas como Bull e BullMQ (muito usadas com NestJS) são baseadas nele.

4. Rate Limiting

Sabe quando você precisa limitar requisições de usuários para evitar abuso?

Redis é perfeito para isso porque:

• trabalha com contadores muito rápidos
• permite reset por intervalo
• suporta TTL (tempo de expiração)

5. Dados em tempo real

Por ser extremamente rápido e trabalhar com streams, Redis funciona super bem em:

• chats
• notificações
• rankings ao vivo
• métricas atualizadas a cada segundo

Como instalar e conectar o Redis ao NestJS (passo a passo simples)

Beleza, agora vamos para o que realmente interessa: colocar o Redis para funcionar dentro de um projeto NestJS.
A boa notícia? É bem mais simples do que parece. Em poucos minutos você já consegue conectar e testar.

Vamos passo a passo:

1. Instalando o Redis na sua máquina

Se você usa Docker (altamente recomendado), basta rodar:

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

Se preferir instalar manualmente, visite o site oficial:
https://redis.io/download

Pronto. Redis rodando localmente na porta 6379.

2. Instalando a lib de integração no NestJS

No projeto NestJS, instale o cliente oficial do Redis:

npm install redis

Ou, se preferir yarn:

yarn add redis

3. Criando um módulo de Redis no NestJS

Vamos criar um módulo simples chamado redis.module.ts para centralizar a conexão:

import { Module, Global } from '@nestjs/common';
import { createClient } from 'redis';

@Global()
@Module({
  providers: [
    {
      provide: 'REDIS_CLIENT',
      useFactory: async () => {
        const client = createClient({
          url: 'redis://localhost:6379',
        });

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

        await client.connect();
        return client;
      },
    },
  ],
  exports: ['REDIS_CLIENT'],
})
export class RedisModule {}

Esse módulo:

• Cria uma conexão
• Trata erros
• Deixa o Redis disponível globalmente no projeto

4. Usando o Redis dentro de um service no NestJS

Agora, basta injetar o cliente Redis onde quiser usar:

import { Inject, Injectable } from '@nestjs/common';
import { RedisClientType } from 'redis';

@Injectable()
export class CacheService {
  constructor(
    @Inject('REDIS_CLIENT')
    private readonly redisClient: RedisClientType,
  ) {}

  async setValue(key: string, value: string, ttl?: number) {
    await this.redisClient.set(key, value);

    if (ttl) {
      await this.redisClient.expire(key, ttl);
    }
  }

  async getValue(key: string) {
    return this.redisClient.get(key);
  }
}

Pronto! Agora o Redis está funcionando no seu NestJS para operações simples de cache.

Exemplos práticos usando Redis no NestJS (cache, sessões e filas)

Agora que o Redis já está conectado ao seu projeto NestJS, vamos ver como ele pode resolver problemas reais.
Esses exemplos são exatamente os que você vai usar em APIs de verdade — desde acelerar consultas até processar tarefas em segundo plano.

1. Usando Redis como Cache (exemplo real de API)

Imagine uma rota que retorna um dado pesado do banco. Antes de buscar a informação, você verifica se ela já está no Redis:

import { Injectable } from '@nestjs/common';
import { CacheService } from './cache.service'; // o service que criamos antes

@Injectable()
export class ProductsService {
  constructor(private readonly cache: CacheService) {}

  async getProducts() {
    const cacheKey = 'products';

    // Tenta pegar do cache
    const cached = await this.cache.getValue(cacheKey);
    if (cached) {
      return JSON.parse(cached);
    }

    // Simulação de consulta pesada
    const products = [
      { id: 1, name: 'Notebook' },
      { id: 2, name: 'Teclado' },
    ];

    // Salva no cache por 60 segundos
    await this.cache.setValue(cacheKey, JSON.stringify(products), 60);

    return products;
  }
}

Resultado:
A primeira chamada consulta o “banco”.
As seguintes pegam direto do Redis — quase instantâneo.

2. Salvando Sessões no Redis

Muito usado em apps de autenticação distribuída (com múltiplas instâncias de API).

Você pode usar libs como connect-redis ou guardar tokens manualmente:

async saveSession(userId: string, token: string) {
  await this.redisClient.set(`session:${userId}`, token, {
    EX: 3600, // expira em 1h
  });
}

async getSession(userId: string) {
  return this.redisClient.get(`session:${userId}`);
}

Perfeito para:

• JWTs temporários
• Sessões de login
• Track de usuários online

3. Filas com Bull + Redis (tarefas em background)

O Redis também é o motor da biblioteca mais usada com NestJS para filas: Bull ou BullMQ.

Instalação:

npm install --save @nestjs/bull bull redis

Configuração da fila:

import { BullModule } from '@nestjs/bull';

@Module({
  imports: [
    BullModule.forRoot({
      redis: {
        host: 'localhost',
        port: 6379,
      },
    }),

    BullModule.registerQueue({
      name: 'emailQueue',
    }),
  ],
})
export class AppModule {}

Enviando tarefas para a fila:

constructor(
  @InjectQueue('emailQueue')
  private queue: Queue
) {}

async sendEmail(data: any) {
  await this.queue.add('send-mail', data);
}

Consumindo tarefas:

@Processor('emailQueue')
export class EmailProcessor {
  @Process('send-mail')
  async handleSendMail(job: Job) {
    console.log('Enviando email...', job.data);
  }
}

Resumo:
Você tira o peso da API e delega tarefas demoradas para workers — tudo usando Redis nos bastidores.

Boas práticas para usar Redis nos seus projetos

Agora que você já sabe como usar o Redis e até integrou com NestJS, vale falar das boas práticas — aquelas dicas que evitam problemas e deixam sua aplicação muito mais estável e performática.

Redis é poderoso, mas se usado de qualquer jeito pode virar dor de cabeça. Vamos ao que realmente importa:

1. Sempre use TTL (tempo de vida) para caches

Um dos erros mais comuns é salvar coisas no Redis sem expiração e acabar lotando a memória.

Sempre que usar Redis como cache:

await this.cache.setValue('key', 'value', 60); // expira em 60s

Sem TTL = memória desperdiçada.

2. Use chaves com nomes claros (key naming)

Essa dica é simples, mas salva vidas:

• Not: user1
• Yes: user:1:session
• Yes: cache:product:list

Padrões bons de seguir:

context:type:id

3. Evite salvar objetos gigantes

Redis é memória RAM. Tudo o que você salva vai afetar o consumo.
Não coloque JSONs enormes, listas com milhares de itens ou blobs pesados.

Se algo é grande demais, volte para o banco tradicional.

4. Monitore o uso de memória

Redis pode começar rápido e terminar lento se você deixar ele abarrotado.

Ferramentas úteis:

• INFO memory
• MONITOR
• Painéis como RedisInsight (super recomendado)

5. Use Redis Cluster em produção

Se sua aplicação cresce, considere usar Redis com:

• Sharding
• Replicação
• Cluster

Assim você evita gargalos em alta escala.

6. Evite usar Redis sozinho como banco principal

Apesar de persistir dados, Redis não substitui um banco relacional (MySQL, Postgres) ou NoSQL de propósito geral (MongoDB).

Ele é um acelerador, não um repositório definitivo.

Projeto prático

Caso deseje aprofundar-se ainda mais. Neste estudo disponibilizo um projeto no meu Github para consulta.

Esta aplicação NestJS demonstra padrões avançados de cache Redis com um sistema completo de gerenciamento de usuários. Ela apresenta estratégias inteligentes de cache, invalidação de cache, monitoramento de desempenho e integração abrangente com o Redis.

Acesse clicando aqui!

Conclusão

E aí, deu pra perceber o porquê o Redis é tão amado no mundo da programação? Ele não é só “mais um banco de dados”, mas sim uma ferramenta incrível para turbinar a performance de qualquer aplicação — especialmente quando integrada com tecnologias modernas como o NestJS.

Com ele você consegue:

• acelerar consultas pesadas,
• controlar sessões de usuários,
• criar filas de processamento,
• trabalhar com dados em tempo real
  — tudo isso consumindo pouquíssimos recursos e com uma velocidade quase absurda.

A chave é saber quando ele realmente faz sentido e aplicar boas práticas para não transformar o Redis num buraco negro de memória. Mas, usado do jeito certo, ele vira um superpoder na sua stack.

E agora eu quero saber de você!

👉 Já usou Redis em algum projeto?
👉 Tem alguma dúvida ou quer ver algum exemplo extra usando NestJS?
👉 Ou quer que eu faça uma parte 2 sobre Redis Streams, Sorted Sets ou filas avançadas?

Deixa seu comentário — vou adorar trocar ideia com você! 🚀