Nest JS : Speed Up API with Cache Redis

Apa itu Cache? Cache adalah mekanisme penyimpanan sementara yang digunakan untuk menyimpan data yang sering diakses agar dapat diambil dengan lebih cepat.

Berikut adalah beberapa kelebihan penggunaan cache:

 

Peningkatan Kinerja:

Caching memungkinkan akses cepat ke data yang sering digunakan. Dengan menyimpan salinan data yang sering diakses di dalam cache, aplikasi dapat menghindari biaya waktu dan sumber daya yang terkait dengan mengambil data dari sumber aslinya.

 

Responsivitas yang Lebih Baik: Dengan mengambil data dari cache daripada sumber aslinya, waktu respons aplikasi dapat dipercepat secara signifikan. Hal ini meningkatkan pengalaman pengguna dan membuat aplikasi terasa lebih responsif.

 

Pengurangan Beban Sumber Daya: Penggunaan cache membantu mengurangi beban pada sumber daya, seperti database atau layanan eksternal. Dengan menghindari eksekusi query atau permintaan ke sumber data utama, cache dapat membantu mengurangi tekanan pada sistem.

Cache dengan redis

Redis adalah salah satu sistem penyimpanan data berkinerja tinggi yang sering digunakan sebagai cache.

Data dalam Redis disimpan di dalam memori (in-memory storage). Hal ini memungkinkan Redis memberikan performa tinggi karena akses ke data lebih cepat dibandingkan dengan penyimpanan di disk.

Penggunaan Cache Redis di dalam Nest JS

Buat Project Nest JS

Jalankan perintah

nest new nest-cache-redis

Kemudian masuk ke project

cd nest-cache-redis

Database & Prisma

Persiapan Database

Buat docker-compose.yml

 

version: '3.9'
services:
  db:
    image: postgres:15.3
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    ports:
      - '5432:5432'

Kemudian jalankan perintah

 

docker compose up --build

Prisma

Install Prisma

yarn add -D prisma

Kemudian jalankan

yarn prisma init

Kemudian setting koneksi database didalam .env file

DATABASE_URL="postgresql://postgres:postgres@localhost:5432/postgres?schema=public"

Lalu edi file prisma/schema.prisma buat model user yang nantinya menjadi table user

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id Int @id @default(autoincrement())

  email String @unique

  name String?
}

Kemudian jalankan perintah

yarn prisma migrate dev

Buat nama migrationnya misal table_user

Kemudian check menggunakan dbeaver

Kemudian tambahkan contoh data user

Lalu buat api sederhana

di dalam app.service.ts buat fungsi untuk menampilkan users

 

import { Injectable } from '@nestjs/common';

import { PrismaClient } from '@prisma/client';


@Injectable()
export class AppService {

  private db = new PrismaClient();

  getHello(): string {
    return 'Hello World!';
  }


 async  getUsers() {
    return this.db.user.findMany();
  }

}

Lalu pada controller app.controller.ts

import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) { }

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }

  @Get('users')
  async getUsers() {
    return await this.appService.getUsers();
  }
}

Test API users

Kemudian buat cache

Cache Dengan Redis

Persiapan Redis

Edit docker-compose.yml dan tambahkan service redis

version: '3.9'

services:
  db:
    image: postgres:15.3
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    ports:
      - '5432:5432'

  redis:
    image: redis
    ports:
      - 6379:6379

Jalankan ulang docker compose

docker compose up --build

Buat module & service cache

jalankan perintah

yarn nest g mo libs/cache
yarn nest g s libs/cache

Install Cache Manager dan Redis

jalankan perintah

yarn add @nestjs/cache-manager cache-manager
yarn add redis cache-manager-redis-store

edit cache.module.ts

import { Module } from '@nestjs/common';
import { CacheService } from './cache.service';
import { CacheModule as CacheMdl } from '@nestjs/cache-manager';
import type { RedisClientOptions } from 'redis';
const redisStore = require('cache-manager-redis-store').redisStore;
@Module({
  imports: [
    CacheMdl.register<RedisClientOptions>({
      store: redisStore,
      url: "redis://localhost:6379"
    }),
  ],
  providers: [CacheService],
  exports:[CacheService]
})
export class CacheModule { }

Kemudian edit cache.service.ts

Buat fungsi setCache dan getCache

import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Inject, Injectable } from '@nestjs/common';
import { Cache } from 'cache-manager';

@Injectable()
export class CacheService {

    constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) { }

    /**
     * Set cache
     * @param key 
     * @param value 
     * @param ttl 
     */
    async setCache(key: string, value: any, ttl: number = 1000) {
        return await this.cacheManager.set(key, value, ttl)
    }

    /**
     * Get cache by key
     * @param key 
     */
    async getCache(key: string) {
        return await this.cacheManager.get(key);
    }

}

Penggunaan Cache

edit app.service.ts

import { CacheService } from './libs/cache/cache.service';

 

constructor(private cache: CacheService){}

  Pada fungsi getUsers

 

  async getUsers() {
    const key = 'users';
    if (await this.cache.getCache(key)) {
      return await this.cache.getCache(key)
    }
    const users = await this.db.user.findMany();
    if(users){
      await this.cache.setCache(key, users, 10000);
    }
    return users;
  }

Kemudian hit API

Check cache redis dengan menggunakan Redis Insight

 

Repository

https://github.com/mister-coding/nestjs-cache-redis-postgre-prisma