Otimize seu Aplicativo com Cache de Dados usando NestJS e Redis

No mundo de desenvolvimento de software, construir aplicações robustas e performáticas são de suma importância.

Pense no seguinte cenário: digamos que você tenha um aplicação de consulta de usuários, e toda vez que alguém entra no perfil de determinado usuário, é preciso realizar uma consulta no banco de dados, certo? E aí vai retornar dados como:

nome, data de nascimento, estado civil, altura, peso, formação, etc.

Raramente essas informações vão mudar, certo? Como evitar que seu servidor consulte sempre o banco de dados?

A resposta é simples: CACHE!

A técnica de cache se baseia no princípio de armazenar temporariamente dados frequentemente acessados em uma área de armazenamento de acesso mais rápido, como a memória RAM, para reduzir o tempo necessário para recuperar esses dados em comparação com a obtenção dos dados diretamente da fonte original, como um banco de dados ou uma API externa.

Vamos utilizar uma ótima solução para realizar essa técnica, o Redis.

Redis é um armazenamento de estrutura de dados em memória, usado como um banco de dados em memória distribuído de chave-valor, cache e agente de mensagens, com durabilidade opcional extremamente rápido.

Desenho da arquitetura

Inicialmente sem cache, sua modelagem fica no seguinte modelo:

Após o cache, ficará assim:

Para realizar o cache é necessário realizar pelo menos uma ou mais vezes consulta no banco de dados, nunca dá pra saber quando o usuário vai querer mudar seus dados, então, quando o servidor realizar uma consulta no Banco de Dados (3), ele irá armazenar esses dados no Redis (4).

A partir desse momento você poderá consultar no Redis os dados:

• Consulta do Redis, se não encontrou os dados:

  • Consulta Banco de Dados
  • Armazena os dados no Redis
  • retorna os dados

• Consulta do Redis, se encontrou os dados:

  • retorna os dados

Iniciando o Projeto

Para esse exemplo, estarei utilizando uma aplicação NestJS + Redis + MongoDB, mas você pode realizar com outros frameworks, como Java utilizando Spring Data Redis + H2, ou GoLang utilizando go-redis + POSTGRES, entre muitas outras.

Para iniciar um aplicativo NestJS, é necessário ter instalado o CLI do Nest:

$ npm install -g @nestjs/cli

Para criar um projeto:

nest new cache-with-redis

Estarei utilizando o Mongoose, como TypeORM para se conectar ao Banco de dados MongoDB.

$ npm i @nestjs/mongoose mongoose

Para o redis, estarei utilizando um Redis Módulo para o Nest:

$ npm install @liaoliaots/nestjs-redis ioredis

Para configurar o projeto utilizando variáveis de ambiente, estarei instalando um módulo do Nest para configuração:

$ npm i --save @nestjs/config

Vamos iniciar configurando um módulo para o Redis, comece criando 2 arquivos:

redis-cache.module.ts
redis-repository.ts

// redis-cache.module.ts
import { RedisModule } from "@liaoliaots/nestjs-redis";
import { Module } from "@nestjs/common";
import { ConfigModule } from "@nestjs/config";
import { RedisCacheRepository } from "./redis-cache.repository";

@Module({
    imports: [
        ConfigModule.forRoot(),
        RedisModule.forRoot({
            config: {
                host: process.env.REDIS_HOST,
                port: Number(process.env.REDIS_PORT),
                password: process.env.REDIS_PASSWORD
            }
        })
    ],
    providers: [RedisCacheRepository],
    exports: [RedisCacheRepository]
})
export class CacheRedisModule {}

// redis-cache.repository.ts
import { InjectRedis } from "@liaoliaots/nestjs-redis";
import { Injectable } from "@nestjs/common";
import Redis from 'ioredis';

@Injectable()
export class RedisCacheRepository {
    constructor(@InjectRedis() private readonly redis: Redis) {}

    async saveData<T>(data: T, key: string): Promise<void> {
        // key -> chave onde o redis irá salvar os dados
        // JSON.stringify(data) -> salvar os dados em JSON
        // EX -> utilizado para indicar que o tempo será passado em segundos
        // 180 -> 180 segundos = 3 minutos de cache
        // Time Complexity -> O(1)
        await this.redis.set(key, JSON.stringify(data), "EX", 180)
    }

    async getData<T>(key: string): Promise<T> {
        // retorna o dado salvo da chave
        // Time Complexity -> O(1)
        return JSON.parse(await this.redis.get(key)) as T;
    }
}

Agora iremos cuidar da nossa entidade Usuário e seu repositório utilizando MongoDB, crie 5 arquivos:

models/user.entity.ts
user.repository.ts
user.servive.ts
user.controller.ts
user.module.ts

// user.entity.ts
import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
import { HydratedDocument } from "mongoose";

export type UserDocument = HydratedDocument<User>;

export enum GenderEnum {
    FEMALE = "Female",
    MALE = "Male"
}

export enum MaritalStatusEnum {
    SINGLE = "Single",
    MARRIED = "Married",
    Divorced = "Divorced",
    Widowed = "Widowed",
    Separated = "Separated"
}

@Schema()
export class User {

    @Prop()
    name: string;

    @Prop()
    age: number;

    @Prop({ type: String, enum: GenderEnum })
    gender: GenderEnum

    @Prop({ type: String, enum: MaritalStatusEnum })
    maritalStatus: MaritalStatusEnum;

    @Prop()
    height: number;
}

export const UserSchema = SchemaFactory.createForClass(User);

// user.repository.ts
import { Injectable } from "@nestjs/common";
import { InjectModel } from "@nestjs/mongoose";
import { User } from "./models/user.entity";
import { Model } from "mongoose";
import { CreateUserDto } from "./dto/create-user.dto";

@Injectable()
export class UserRepository {
    constructor(@InjectModel(User.name) private readonly userModel: Model<User>) {}

    async create(createUserDto: CreateUserDto): Promise<User> {
        const userCreated = new this.userModel(createUserDto);
        return userCreated.save();
    }

    async findById(userId: string): Promise<User> {
        return await this.userModel.findById(userId);
    }
}

// user.servive.ts
import { Injectable } from "@nestjs/common";
import { UserRepository } from "./user.repository";
import { RedisCacheRepository } from "src/redis-cache/redis-cache.repository";
import { CreateUserDto } from "./dto/create-user.dto";

@Injectable()
export class UserService {
    constructor(
        private readonly userRepository: UserRepository,
        private readonly redisCacheRepository: RedisCacheRepository
    ) {}

    async getUserById(userId: string) {
        const userCache = await this.redisCacheRepository.getData(userId);

        if (userCache) {
            return userCache;
        }

        const userRepository = await this.userRepository.findById(userId);

        await this.redisCacheRepository.saveData(userRepository._id, userRepository);

        return userRepository;
    }

    async saveUser(userCreateDto: CreateUserDto) {
        return await this.userRepository.create(userCreateDto);
    }
}

// user.controller.ts
import { Body, Controller, Get, HttpStatus, Param, Post, Res } from "@nestjs/common";
import { UserService } from "./user.service";
import { CreateUserDto } from "./dto/create-user.dto";
import { Response } from "express";

@Controller("user")
export class UserController {
    constructor(private readonly userService: UserService) {}

    @Post()
    async postUser(@Body() userDto: CreateUserDto, @Res() res: Response) {
        const userCreated = await this.userService.saveUser(userDto);

        res.status(HttpStatus.OK).json(userCreated);
    }

    @Get(":id")
    async get(@Param("id") id: string, @Res() res: Response) {
        const user = await this.userService.getUserById(id);

        res.status(HttpStatus.OK).json(user);
    }
}

É importante criar um arquivo .env no root do projeto:

# .env
REDIS_HOST=127.0.0.1
REDIS_PORT=6379
REDIS_PASSWORD=password
MONGODB_HOST="mongodb://127.0.0.1:27017/CACHE_WITH_REDIS"

Pronto, a aplicação está pronta para ser executada. Você pode executar executando o comando:

$ npm run start

Logo após verá um saída dessa forma:

Para salvar um usuário, podemos realizar uma requisição do tipo POST com o curl:

curl --location 'localhost:3000/user' \
--header 'Content-Type: application/json' \
--data '{
  "name": "John Doe",
  "age": 30,
  "gender": "Male",
  "maritalStatus": "Married",
  "height": 1.80
}'

Logo após retornará algo do gênero:

Redis em Ação

Agora veremos o Redis em Ação, ao realizar uma requisição do método GET para obter o usuário:

curl --location 'localhost:3000/user/6619fa598d1a2e8cb93a95f3'

Vamos obter o seguinte resultado:

Repare que a resposta volta com o seguinte tempo de resposta: 34ms. De acordo com nossa regra de negócio, ele faz uma consulta no Redis, se não achar, ele vai no Banco de Dados(MongoDB), logo após salva no redis e retorna, certo? Boa, vamos ver se salvou no redis?

# Redis CLI
> GET 6619fa598d1a2e8cb93a95f3
"{\"_id\":\"6619fa598d1a2e8cb93a95f3\",\"name\":\"John Doe\",\"age\":30,\"gender\":\"Male\",\"maritalStatus\":\"Married\",\"height\":1.8,\"__v\":0}"

Olha que legal, agora o nosso dado está salvo no Redis, vamos ver se melhorou o tempo de resposta da API?

4ms, isso é um absurdo de rápido. Você deve estar pensando: "Caramba, só 29ms de diferença, isso não faz diferença."
Em ambientes escaláveis e robustos que necessitam de sistemas rápidos, como o PIX, qualquer diferença de tempo muda. Imagine quando você precisar cachear o resultado de alguma API externa em que você utiliza que não muda muito o resultado, seria de grande utilidade, certo?

Chegamos ao final. Espero que tenham gostado, estarei deixando alguns links de referência:

Configuration NestJS
MongoDB NestJS
Redis Module NestJS
SET command Redis
GET command Redis

O link do repositório utilizado no tutorial se encontra aqui:
Projeto Repositório

Um Abraço e bons estudos! Até mais!