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

shell
nest new nest-cache-redis

Kemudian masuk ke project

shell
cd nest-cache-redis

Database & Prisma

Persiapan Database

Buat docker-compose.yml

 

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

Kemudian jalankan perintah

 

shell
docker compose up --build

Prisma

Install Prisma

shell
yarn add -D prisma

Kemudian jalankan

shell
yarn prisma init

Kemudian setting koneksi database didalam .env file

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

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

javascript
// 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

shell
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

 

javascript
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

javascript
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

javascript
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

shell
docker compose up --build

Buat module & service cache

jalankan perintah

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

Install Cache Manager dan Redis

jalankan perintah

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

edit cache.module.ts

javascript
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

javascript
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

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

 

javascript
constructor(private cache: CacheService){}

  Pada fungsi getUsers

 

javascript
  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