Fundamental Redis - Tipe Data, Use Case, dan Membangun API NestJS Real-World

#Pengenalan

Redis ada di mana-mana dalam sistem backend modern. Ia mendukung session management di GitHub, caching di Twitter, real-time leaderboards di platform gaming, dan pub/sub messaging di Slack. Namun banyak developer memperlakukannya sebagai "hanya cache"—sebuah kesempatan yang terlewatkan.

Redis adalah in-memory data structure store yang dapat berfungsi sebagai database, cache, message broker, dan streaming engine. Memahami tipe data dan kapan menggunakan masing-masing mengubah cara Anda merancang sistem. Dalam artikel ini, kita akan mengeksplorasi fundamental Redis, menyelami setiap tipe data dengan use case real-world, dan membangun API NestJS siap produksi yang mendemonstrasikan session management, caching, rate limiting, dan fitur real-time.

#Mengapa Redis Ada

#Masalah Kecepatan

Database tradisional menyimpan data di disk. Bahkan dengan SSD, disk I/O jauh lebih lambat dari RAM:

Akses RAM: ~100 nanodetik
Akses SSD: ~100 mikrodetik (1000x lebih lambat)
Akses HDD: ~10 milidetik (100,000x lebih lambat)

Ketika Anda membutuhkan response time sub-milidetik—session lookups, cache hits, real-time analytics—database berbasis disk tidak bisa bersaing.

#Masalah Kompleksitas

Sebelum Redis, developer membangun caching layers dengan Memcached atau solusi custom. Ini bekerja untuk simple key-value storage tetapi gagal untuk:

Atomic counters (page views, rate limiting)
Sorted sets (leaderboards, priority queues)
Pub/sub messaging (real-time notifications)
Geospatial queries (location-based services)

Redis menyelesaikan ini dengan menyediakan rich data structures dengan atomic operations, semuanya in-memory.

#Konsep Inti Redis

#In-Memory Storage

Redis menyimpan semua data di RAM, membuat reads dan writes sangat cepat. Data dapat dipersist ke disk menggunakan:

RDB (Redis Database): Point-in-time snapshots
AOF (Append-Only File): Log dari setiap write operation
Hybrid: Kombinasi keduanya untuk durability dan performance

#Single-Threaded Architecture

Redis menggunakan single-threaded event loop untuk eksekusi command. Ini menghilangkan race conditions dan membuat operations atomic secara default. Meskipun terdengar membatasi, Redis dapat menangani jutaan operations per detik karena:

Tidak ada context switching overhead
Tidak ada lock contention
I/O multiplexing menangani concurrent connections
Redis modern menggunakan I/O threads untuk network operations

#Atomic Operations

Setiap Redis command adalah atomic. Ini crucial untuk:

Increment counters tanpa race conditions
Implementasi distributed locks
Membangun rate limiters
Mengelola session state di multiple servers

#Deep Dive Tipe Data Redis

#1. Strings

Tipe data paling sederhana. Menyimpan text, numbers, atau binary data hingga 512MB.

Common Commands:

String operations

SET user:1000:name "John Doe"
GET user:1000:name
INCR page:views
INCRBY user:1000:credits 100
SETEX session:abc123 3600 "user_data"  # Expires dalam 1 jam

Real-World Use Cases:

Session Storage
- Simpan serialized session data dengan TTL
- Fast lookups by session ID
- Automatic expiration
Caching API Responses
- Cache expensive database queries
- Simpan computed results
- Kurangi backend load
Rate Limiting
- Hitung requests per user/IP
- Atomic increments mencegah race conditions
- TTL untuk automatic reset
Feature Flags
- Simpan boolean flags
- Instant updates di semua servers
- Tidak perlu database queries

Contoh: Rate Limiting

bash

# Izinkan 100 requests per menit
SET rate:user:1000 0 EX 60 NX
INCR rate:user:1000
# Jika result > 100, reject request

#2. Hashes

Simpan field-value pairs di bawah single key. Perfect untuk merepresentasikan objects.

Common Commands:

Hash operations

HSET user:1000 name "John" email "john@example.com" age 30
HGET user:1000 name
HGETALL user:1000
HINCRBY user:1000 age 1
HMGET user:1000 name email

Real-World Use Cases:

User Profiles
- Simpan user attributes secara efisien
- Update individual fields tanpa fetch entire object
- Memory efficient dibanding JSON strings
Product Catalogs
- Simpan product details
- Quick field updates (price, stock)
- Atomic field operations
Configuration Management
- Application settings per environment
- Feature toggles dengan metadata
- Dynamic configuration updates
Shopping Carts
- Item ID sebagai field, quantity sebagai value
- Atomic quantity updates
- Mudah add/remove items

Mengapa Gunakan Hashes Daripada Strings?

bash

# ❌ String approach - harus serialize/deserialize entire object
SET user:1000 '{"name":"John","email":"john@example.com","age":30}'
 
# ✅ Hash approach - update individual fields
HSET user:1000 age 31  # Hanya update age field

#3. Lists

Ordered collections dari strings. Diimplementasikan sebagai linked lists.

Common Commands:

List operations

LPUSH queue:tasks "task1" "task2"
RPUSH queue:tasks "task3"
LPOP queue:tasks
RPOP queue:tasks
LRANGE queue:tasks 0 -1
LTRIM queue:tasks 0 99  # Simpan hanya 100 items pertama

Real-World Use Cases:

Task Queues
- Background job processing
- FIFO atau LIFO ordering
- Blocking operations untuk workers
Activity Feeds
- Recent user activities
- Timeline posts
- Trim untuk simpan hanya N items terbaru
Message Queues
- Simple pub/sub alternative
- Guaranteed delivery dengan BRPOPLPUSH
- Multiple consumers
Undo/Redo Stacks
- Simpan operation history
- LPUSH untuk new operations
- LPOP untuk undo

Contoh: Reliable Queue Pattern

bash

# Pindahkan task dari queue ke processing list secara atomic
BRPOPLPUSH queue:tasks queue:processing 0
 
# Setelah processing, hapus dari processing list
LREM queue:processing 1 "task_data"

#4. Sets

Unordered collections dari unique strings. Fast membership testing.

Common Commands:

Set operations

SADD tags:post:1 "redis" "database" "caching"
SMEMBERS tags:post:1
SISMEMBER tags:post:1 "redis"
SINTER tags:post:1 tags:post:2  # Intersection
SUNION tags:post:1 tags:post:2  # Union
SCARD tags:post:1  # Count members

Real-World Use Cases:

Tagging Systems
- Simpan tags per item
- Temukan items dengan specific tags
- Tag intersection/union queries
Unique Visitor Tracking
- Tambahkan user IDs ke daily set
- Hitung unique visitors dengan SCARD
- Temukan common visitors di berbagai hari
Social Graphs
- Simpan followers/following
- Temukan mutual friends (SINTER)
- Suggest friends (SDIFF)
Access Control
- Simpan user permissions
- Fast permission checks
- Role-based access control

Contoh: Friend Recommendations

bash

# Temukan friends of friends yang belum menjadi friends
SADD friends:user:1 "user:2" "user:3"
SADD friends:user:2 "user:1" "user:4" "user:5"
 
# Dapatkan friends user:2, exclude user:1 dan existing friends mereka
SDIFF friends:user:2 friends:user:1
# Result: user:4, user:5 (potential friend suggestions)

#5. Sorted Sets (ZSets)

Sets dengan score untuk setiap member. Members diurutkan berdasarkan score.

Common Commands:

Sorted set operations

ZADD leaderboard 100 "player1" 200 "player2" 150 "player3"
ZRANGE leaderboard 0 -1 WITHSCORES
ZREVRANGE leaderboard 0 9  # Top 10
ZINCRBY leaderboard 50 "player1"
ZRANK leaderboard "player1"
ZCOUNT leaderboard 100 200

Real-World Use Cases:

Leaderboards
- Gaming scores
- User rankings
- Top performers
Priority Queues
- Task scheduling by priority
- Event processing by timestamp
- Job queues dengan deadlines
Time-Series Data
- Simpan events dengan timestamps sebagai scores
- Query by time range
- Sliding window analytics
Auto-Complete
- Simpan terms dengan popularity scores
- Return top N suggestions
- Update scores berdasarkan usage

Contoh: Real-Time Leaderboard

bash

# Tambahkan player score
ZADD game:leaderboard 1500 "player:123"
 
# Dapatkan player rank (0-indexed)
ZREVRANK game:leaderboard "player:123"
 
# Dapatkan top 10 players
ZREVRANGE game:leaderboard 0 9 WITHSCORES
 
# Dapatkan players dalam score range
ZRANGEBYSCORE game:leaderboard 1000 2000

#6. Bitmaps

Bukan tipe data terpisah, tetapi string operations di bit level. Sangat memory efficient.

Common Commands:

Bitmap operations

SETBIT user:1000:login:2024-02-21 0 1  # User logged in
GETBIT user:1000:login:2024-02-21 0
BITCOUNT user:1000:login:2024-02-21  # Hitung login days
BITOP AND result key1 key2  # Bitwise operations

Real-World Use Cases:

User Activity Tracking
- Daily active users
- Login streaks
- Feature usage tracking
Real-Time Analytics
- Track events per user per day
- Memory efficient (1 bit per event)
- Fast aggregations
A/B Testing
- Track variant mana yang users lihat
- Efficient storage untuk jutaan users
- Quick cohort analysis

Contoh: Daily Active Users

bash

# Tandai user 1000 sebagai active di day 0
SETBIT dau:2024-02-21 1000 1
 
# Hitung total active users
BITCOUNT dau:2024-02-21
 
# Temukan users active di kedua hari
BITOP AND dau:both dau:2024-02-21 dau:2024-02-22
BITCOUNT dau:both

#7. HyperLogLog

Probabilistic data structure untuk menghitung unique items. Menggunakan fixed 12KB memory terlepas dari cardinality.

Common Commands:

HyperLogLog operations

PFADD unique:visitors:2024-02-21 "user1" "user2" "user3"
PFCOUNT unique:visitors:2024-02-21
PFMERGE unique:visitors:week day1 day2 day3

Real-World Use Cases:

Unique Visitor Counting
- Hitung unique IPs/users
- 0.81% error rate
- Constant memory usage
Unique Search Queries
- Track distinct queries
- Aggregate di berbagai time periods
- Memory efficient at scale
Cardinality Estimation
- Unique product views
- Distinct error types
- Unique API consumers

Mengapa Gunakan HyperLogLog?

bash

# ❌ Set approach - memory tumbuh dengan unique items
SADD visitors:2024-02-21 "user1" "user2" ... # Bisa jutaan
 
# ✅ HyperLogLog - fixed 12KB memory
PFADD visitors:2024-02-21 "user1" "user2" ... # Selalu 12KB

#8. Geospatial

Simpan dan query geographic coordinates.

Common Commands:

Geospatial operations

GEOADD locations 13.361389 38.115556 "Palermo"
GEOADD locations 15.087269 37.502669 "Catania"
GEODIST locations "Palermo" "Catania" km
GEORADIUS locations 15 37 200 km WITHDIST
GEOSEARCH locations FROMLONLAT 15 37 BYRADIUS 100 km

Real-World Use Cases:

Location-Based Services
- Temukan restoran terdekat
- Driver matching (Uber, Lyft)
- Store locators
Delivery Routing
- Temukan delivery person terdekat
- Hitung distances
- Optimize routes
Geofencing
- Trigger actions ketika entering area
- Location-based notifications
- Regional content delivery

#9. Streams

Append-only log data structure untuk event streaming dan message queues.

Common Commands:

Stream operations

XADD events * action "login" user "1000"
XREAD COUNT 10 STREAMS events 0
XGROUP CREATE events processors 0
XREADGROUP GROUP processors consumer1 COUNT 1 STREAMS events >
XACK events processors <message-id>

Real-World Use Cases:

Event Sourcing
- Simpan semua state changes
- Replay events
- Audit logs
Message Queues
- Multiple consumers
- Consumer groups
- Guaranteed delivery
Real-Time Analytics
- Process event streams
- Time-series data
- Aggregations
Activity Feeds
- User actions
- System events
- Notifications

#Membangun API NestJS Real-World dengan Redis

Sekarang mari kita bangun API siap produksi yang mendemonstrasikan Redis dalam aksi. Kita akan membuat platform blog dengan:

User authentication dengan session management
Post caching dengan automatic invalidation
Rate limiting per user
Real-time view counters
Trending posts menggunakan sorted sets

#Project Setup

Buat NestJS project

npm i -g @nestjs/cli
nest new redis-blog-api
cd redis-blog-api
npm install ioredis @nestjs/throttler class-validator class-transformer

#Langkah 1: Konfigurasi Redis

src/redis/redis.module.ts

import { Module, Global } from '@nestjs/common';
import { RedisService } from './redis.service';
 
@Global()
@Module({
  providers: [RedisService],
  exports: [RedisService],
})
export class RedisModule {}

src/redis/redis.service.ts

import { Injectable, OnModuleDestroy } from '@nestjs/common';
import Redis from 'ioredis';
 
@Injectable()
export class RedisService implements OnModuleDestroy {
  private readonly client: Redis;
 
  constructor() {
    this.client = new Redis({
      host: process.env.REDIS_HOST || 'localhost',
      port: parseInt(process.env.REDIS_PORT) || 6379,
      password: process.env.REDIS_PASSWORD,
      retryStrategy: (times) => {
        const delay = Math.min(times * 50, 2000);
        return delay;
      },
    });
 
    this.client.on('error', (err) => {
      console.error('Redis Client Error', err);
    });
 
    this.client.on('connect', () => {
      console.log('Redis Client Connected');
    });
  }
 
  getClient(): Redis {
    return this.client;
  }
 
  async onModuleDestroy() {
    await this.client.quit();
  }
 
  // String operations
  async set(key: string, value: string, ttl?: number): Promise<void> {
    if (ttl) {
      await this.client.setex(key, ttl, value);
    } else {
      await this.client.set(key, value);
    }
  }
 
  async get(key: string): Promise<string | null> {
    return this.client.get(key);
  }
 
  async del(key: string): Promise<number> {
    return this.client.del(key);
  }
 
  async incr(key: string): Promise<number> {
    return this.client.incr(key);
  }
 
  // Hash operations
  async hset(key: string, field: string, value: string): Promise<number> {
    return this.client.hset(key, field, value);
  }
 
  async hgetall(key: string): Promise<Record<string, string>> {
    return this.client.hgetall(key);
  }
 
  async hget(key: string, field: string): Promise<string | null> {
    return this.client.hget(key, field);
  }
 
  // Sorted set operations
  async zadd(key: string, score: number, member: string): Promise<number> {
    return this.client.zadd(key, score, member);
  }
 
  async zincrby(key: string, increment: number, member: string): Promise<string> {
    return this.client.zincrby(key, increment, member);
  }
 
  async zrevrange(
    key: string,
    start: number,
    stop: number,
    withScores?: boolean,
  ): Promise<string[]> {
    if (withScores) {
      return this.client.zrevrange(key, start, stop, 'WITHSCORES');
    }
    return this.client.zrevrange(key, start, stop);
  }
 
  // Set operations
  async sadd(key: string, ...members: string[]): Promise<number> {
    return this.client.sadd(key, ...members);
  }
 
  async smembers(key: string): Promise<string[]> {
    return this.client.smembers(key);
  }
 
  async sismember(key: string, member: string): Promise<number> {
    return this.client.sismember(key, member);
  }
}

#Langkah 2: Session Management

src/auth/session.service.ts

import { Injectable } from '@nestjs/common';
import { RedisService } from '../redis/redis.service';
import { randomBytes } from 'crypto';
 
interface SessionData {
  userId: string;
  email: string;
  createdAt: number;
}
 
@Injectable()
export class SessionService {
  private readonly SESSION_PREFIX = 'session:';
  private readonly SESSION_TTL = 86400; // 24 jam
 
  constructor(private readonly redis: RedisService) {}
 
  async createSession(userId: string, email: string): Promise<string> {
    const sessionId = randomBytes(32).toString('hex');
    const sessionKey = `${this.SESSION_PREFIX}${sessionId}`;
 
    const sessionData: SessionData = {
      userId,
      email,
      createdAt: Date.now(),
    };
 
    await this.redis.set(
      sessionKey,
      JSON.stringify(sessionData),
      this.SESSION_TTL,
    );
 
    return sessionId;
  }
 
  async getSession(sessionId: string): Promise<SessionData | null> {
    const sessionKey = `${this.SESSION_PREFIX}${sessionId}`;
    const data = await this.redis.get(sessionKey);
 
    if (!data) {
      return null;
    }
 
    return JSON.parse(data);
  }
 
  async refreshSession(sessionId: string): Promise<boolean> {
    const sessionKey = `${this.SESSION_PREFIX}${sessionId}`;
    const data = await this.redis.get(sessionKey);
 
    if (!data) {
      return false;
    }
 
    await this.redis.set(sessionKey, data, this.SESSION_TTL);
    return true;
  }
 
  async destroySession(sessionId: string): Promise<void> {
    const sessionKey = `${this.SESSION_PREFIX}${sessionId}`;
    await this.redis.del(sessionKey);
  }
 
  async getUserSessions(userId: string): Promise<string[]> {
    const pattern = `${this.SESSION_PREFIX}*`;
    const client = this.redis.getClient();
    const keys = await client.keys(pattern);
 
    const sessions: string[] = [];
 
    for (const key of keys) {
      const data = await this.redis.get(key);
      if (data) {
        const session: SessionData = JSON.parse(data);
        if (session.userId === userId) {
          sessions.push(key.replace(this.SESSION_PREFIX, ''));
        }
      }
    }
 
    return sessions;
  }
}

#Langkah 3: Rate Limiting

src/common/guards/rate-limit.guard.ts

import {
  Injectable,
  CanActivate,
  ExecutionContext,
  HttpException,
  HttpStatus,
} from '@nestjs/common';
import { RedisService } from '../../redis/redis.service';
 
@Injectable()
export class RateLimitGuard implements CanActivate {
  private readonly RATE_LIMIT_PREFIX = 'rate_limit:';
  private readonly MAX_REQUESTS = 100;
  private readonly WINDOW_SIZE = 60; // 60 detik
 
  constructor(private readonly redis: RedisService) {}
 
  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const userId = request.user?.userId || request.ip;
 
    const key = `${this.RATE_LIMIT_PREFIX}${userId}`;
    const client = this.redis.getClient();
 
    const current = await client.incr(key);
 
    if (current === 1) {
      await client.expire(key, this.WINDOW_SIZE);
    }
 
    if (current > this.MAX_REQUESTS) {
      throw new HttpException(
        'Terlalu banyak requests. Silakan coba lagi nanti.',
        HttpStatus.TOO_MANY_REQUESTS,
      );
    }
 
    // Tambahkan rate limit info ke response headers
    const ttl = await client.ttl(key);
    request.res.setHeader('X-RateLimit-Limit', this.MAX_REQUESTS);
    request.res.setHeader('X-RateLimit-Remaining', this.MAX_REQUESTS - current);
    request.res.setHeader('X-RateLimit-Reset', Date.now() + ttl * 1000);
 
    return true;
  }
}

#Langkah 4: Post Caching Service

src/posts/cache.service.ts

import { Injectable } from '@nestjs/common';
import { RedisService } from '../redis/redis.service';
 
interface Post {
  id: string;
  title: string;
  content: string;
  authorId: string;
  createdAt: Date;
  views: number;
}
 
@Injectable()
export class PostCacheService {
  private readonly POST_CACHE_PREFIX = 'post:';
  private readonly POST_LIST_KEY = 'posts:all';
  private readonly TRENDING_KEY = 'posts:trending';
  private readonly CACHE_TTL = 3600; // 1 jam
 
  constructor(private readonly redis: RedisService) {}
 
  async cachePost(post: Post): Promise<void> {
    const key = `${this.POST_CACHE_PREFIX}${post.id}`;
    await this.redis.set(key, JSON.stringify(post), this.CACHE_TTL);
  }
 
  async getPost(postId: string): Promise<Post | null> {
    const key = `${this.POST_CACHE_PREFIX}${postId}`;
    const data = await this.redis.get(key);
 
    if (!data) {
      return null;
    }
 
    return JSON.parse(data);
  }
 
  async invalidatePost(postId: string): Promise<void> {
    const key = `${this.POST_CACHE_PREFIX}${postId}`;
    await this.redis.del(key);
  }
 
  async incrementViews(postId: string): Promise<number> {
    const viewKey = `${this.POST_CACHE_PREFIX}${postId}:views`;
    const views = await this.redis.incr(viewKey);
 
    // Update trending score (views dalam 24 jam terakhir)
    await this.redis.zincrby(this.TRENDING_KEY, 1, postId);
 
    return views;
  }
 
  async getViews(postId: string): Promise<number> {
    const viewKey = `${this.POST_CACHE_PREFIX}${postId}:views`;
    const views = await this.redis.get(viewKey);
    return views ? parseInt(views) : 0;
  }
 
  async getTrendingPosts(limit: number = 10): Promise<string[]> {
    return this.redis.zrevrange(this.TRENDING_KEY, 0, limit - 1);
  }
 
  async cachePostList(posts: Post[]): Promise<void> {
    await this.redis.set(
      this.POST_LIST_KEY,
      JSON.stringify(posts),
      this.CACHE_TTL,
    );
  }
 
  async getPostList(): Promise<Post[] | null> {
    const data = await this.redis.get(this.POST_LIST_KEY);
    if (!data) {
      return null;
    }
    return JSON.parse(data);
  }
 
  async invalidatePostList(): Promise<void> {
    await this.redis.del(this.POST_LIST_KEY);
  }
 
  async addToUserPosts(userId: string, postId: string): Promise<void> {
    const key = `user:${userId}:posts`;
    await this.redis.sadd(key, postId);
  }
 
  async getUserPosts(userId: string): Promise<string[]> {
    const key = `user:${userId}:posts`;
    return this.redis.smembers(key);
  }
}

#Langkah 5: Posts Controller

src/posts/posts.controller.ts

import {
  Controller,
  Get,
  Post,
  Put,
  Delete,
  Body,
  Param,
  UseGuards,
  Request,
} from '@nestjs/common';
import { PostsService } from './posts.service';
import { PostCacheService } from './cache.service';
import { RateLimitGuard } from '../common/guards/rate-limit.guard';
import { AuthGuard } from '../common/guards/auth.guard';
 
@Controller('posts')
@UseGuards(RateLimitGuard)
export class PostsController {
  constructor(
    private readonly postsService: PostsService,
    private readonly cacheService: PostCacheService,
  ) {}
 
  @Get()
  async findAll() {
    // Coba cache dulu
    const cached = await this.cacheService.getPostList();
    if (cached) {
      return { source: 'cache', data: cached };
    }
 
    // Cache miss - fetch dari database
    const posts = await this.postsService.findAll();
    await this.cacheService.cachePostList(posts);
 
    return { source: 'database', data: posts };
  }
 
  @Get('trending')
  async getTrending() {
    const postIds = await this.cacheService.getTrendingPosts(10);
    const posts = await Promise.all(
      postIds.map(async (id) => {
        const cached = await this.cacheService.getPost(id);
        if (cached) return cached;
        return this.postsService.findOne(id);
      }),
    );
 
    return posts.filter(Boolean);
  }
 
  @Get(':id')
  async findOne(@Param('id') id: string) {
    // Coba cache dulu
    const cached = await this.cacheService.getPost(id);
    if (cached) {
      // Increment views secara asynchronous
      this.cacheService.incrementViews(id);
      return { source: 'cache', data: cached };
    }
 
    // Cache miss - fetch dari database
    const post = await this.postsService.findOne(id);
    if (post) {
      await this.cacheService.cachePost(post);
      await this.cacheService.incrementViews(id);
    }
 
    return { source: 'database', data: post };
  }
 
  @Post()
  @UseGuards(AuthGuard)
  async create(@Body() createPostDto: any, @Request() req) {
    const post = await this.postsService.create({
      ...createPostDto,
      authorId: req.user.userId,
    });
 
    // Cache post baru
    await this.cacheService.cachePost(post);
 
    // Tambahkan ke user's posts
    await this.cacheService.addToUserPosts(req.user.userId, post.id);
 
    // Invalidate post list cache
    await this.cacheService.invalidatePostList();
 
    return post;
  }
 
  @Put(':id')
  @UseGuards(AuthGuard)
  async update(
    @Param('id') id: string,
    @Body() updatePostDto: any,
    @Request() req,
  ) {
    const post = await this.postsService.update(id, updatePostDto);
 
    // Invalidate cache
    await this.cacheService.invalidatePost(id);
    await this.cacheService.invalidatePostList();
 
    return post;
  }
 
  @Delete(':id')
  @UseGuards(AuthGuard)
  async remove(@Param('id') id: string) {
    await this.postsService.remove(id);
 
    // Invalidate cache
    await this.cacheService.invalidatePost(id);
    await this.cacheService.invalidatePostList();
 
    return { message: 'Post berhasil dihapus' };
  }
 
  @Get(':id/views')
  async getViews(@Param('id') id: string) {
    const views = await this.cacheService.getViews(id);
    return { postId: id, views };
  }
}

#Langkah 6: Authentication Controller

src/auth/auth.controller.ts

import { Controller, Post, Delete, Body, Headers, HttpException, HttpStatus } from '@nestjs/common';
import { SessionService } from './session.service';
import { UsersService } from '../users/users.service';
 
@Controller('auth')
export class AuthController {
  constructor(
    private readonly sessionService: SessionService,
    private readonly usersService: UsersService,
  ) {}
 
  @Post('login')
  async login(@Body() loginDto: { email: string; password: string }) {
    // Validasi credentials (simplified)
    const user = await this.usersService.validateUser(
      loginDto.email,
      loginDto.password,
    );
 
    if (!user) {
      throw new HttpException('Credentials tidak valid', HttpStatus.UNAUTHORIZED);
    }
 
    // Buat session
    const sessionId = await this.sessionService.createSession(
      user.id,
      user.email,
    );
 
    return {
      sessionId,
      user: {
        id: user.id,
        email: user.email,
      },
    };
  }
 
  @Post('logout')
  async logout(@Headers('authorization') auth: string) {
    const sessionId = auth?.replace('Bearer ', '');
 
    if (!sessionId) {
      throw new HttpException('Tidak ada session', HttpStatus.BAD_REQUEST);
    }
 
    await this.sessionService.destroySession(sessionId);
 
    return { message: 'Berhasil logout' };
  }
 
  @Post('refresh')
  async refresh(@Headers('authorization') auth: string) {
    const sessionId = auth?.replace('Bearer ', '');
 
    if (!sessionId) {
      throw new HttpException('Tidak ada session', HttpStatus.BAD_REQUEST);
    }
 
    const refreshed = await this.sessionService.refreshSession(sessionId);
 
    if (!refreshed) {
      throw new HttpException('Session tidak valid', HttpStatus.UNAUTHORIZED);
    }
 
    return { message: 'Session di-refresh' };
  }
}

#Langkah 7: Environment Configuration

.env

# Redis Configuration
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=
 
# Application
PORT=3000
NODE_ENV=development

#Langkah 8: Docker Compose untuk Local Development

docker-compose.yml

version: '3.8'
 
services:
  redis:
    image: redis:7-alpine
    ports:
      - '6379:6379'
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes
    healthcheck:
      test: ['CMD', 'redis-cli', 'ping']
      interval: 5s
      timeout: 3s
      retries: 5
 
  redis-commander:
    image: rediscommander/redis-commander:latest
    environment:
      - REDIS_HOSTS=local:redis:6379
    ports:
      - '8081:8081'
    depends_on:
      - redis
 
volumes:
  redis_data:

#Langkah 9: Menjalankan Aplikasi

Start services

# Start Redis
docker-compose up -d
 
# Install dependencies
npm install
 
# Run application
npm run start:dev

#Testing API

Test endpoints

# Login
curl -X POST http://localhost:3000/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com","password":"password123"}'
 
# Response: {"sessionId":"abc123...","user":{...}}
 
# Buat post (dengan session)
curl -X POST http://localhost:3000/posts \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer abc123..." \
  -d '{"title":"Redis Guide","content":"Belajar Redis..."}'
 
# Dapatkan semua posts (cached)
curl http://localhost:3000/posts
 
# Dapatkan single post (cached + increment views)
curl http://localhost:3000/posts/1
 
# Dapatkan trending posts
curl http://localhost:3000/posts/trending
 
# Dapatkan post views
curl http://localhost:3000/posts/1/views
 
# Test rate limiting (buat 101 requests)
for i in {1..101}; do
  curl http://localhost:3000/posts
done
# Setelah 100 requests: 429 Too Many Requests

#Kesalahan Umum & Pitfalls

#1. Tidak Set TTL pada Keys

Keys tanpa expiration dapat menyebabkan memory leaks.

// ❌ Salah - key hidup selamanya
await redis.set('session:abc123', sessionData);
 
// ✅ Benar - key expires secara otomatis
await redis.setex('session:abc123', 3600, sessionData);

#2. Menggunakan KEYS Command di Production

KEYS memblokir Redis saat scanning semua keys. Gunakan SCAN sebagai gantinya.

// ❌ Salah - blocks Redis
const keys = await redis.keys('user:*');
 
// ✅ Benar - non-blocking iteration
const stream = redis.scanStream({ match: 'user:*', count: 100 });
stream.on('data', (keys) => {
  // Process keys
});

#3. Menyimpan Large Values

Redis dioptimalkan untuk small values. Large values (>1MB) merusak performance.

// ❌ Salah - menyimpan 10MB JSON
await redis.set('data', JSON.stringify(hugeObject));
 
// ✅ Benar - gunakan compression atau split data
const compressed = gzip(JSON.stringify(hugeObject));
await redis.set('data', compressed);
 
// Atau split ke chunks
await redis.hset('data', 'chunk1', part1);
await redis.hset('data', 'chunk2', part2);

#4. Tidak Handle Connection Failures

Redis connections bisa fail. Implementasikan retry logic dan error handling.

// ✅ Proper error handling
const redis = new Redis({
  retryStrategy: (times) => {
    const delay = Math.min(times * 50, 2000);
    return delay;
  },
  maxRetriesPerRequest: 3,
});
 
redis.on('error', (err) => {
  logger.error('Redis error:', err);
  // Alert monitoring system
});

#5. Race Conditions dengan Cache Invalidation

Multiple requests dapat menyebabkan cache stampede.

// ❌ Salah - cache stampede mungkin terjadi
const cached = await redis.get('posts');
if (!cached) {
  const posts = await db.getPosts(); // Multiple requests hit DB
  await redis.set('posts', JSON.stringify(posts));
}
 
// ✅ Benar - gunakan locking
const lockKey = 'lock:posts';
const lock = await redis.set(lockKey, '1', 'EX', 10, 'NX');
 
if (lock) {
  try {
    const posts = await db.getPosts();
    await redis.set('posts', JSON.stringify(posts), 'EX', 3600);
  } finally {
    await redis.del(lockKey);
  }
} else {
  // Wait dan retry
  await sleep(100);
  return getCachedPosts();
}

#6. Tidak Monitor Memory Usage

Redis menyimpan semuanya di RAM. Monitor memory dan set limits.

Konfigurasi memory limits

# Set max memory
CONFIG SET maxmemory 2gb
 
# Set eviction policy
CONFIG SET maxmemory-policy allkeys-lru
 
# Monitor memory
INFO memory

#Best Practices

#1. Gunakan Tipe Data yang Sesuai

Pilih tipe data yang tepat untuk use case Anda:

Strings: Simple values, serialized objects
Hashes: Objects dengan multiple fields
Lists: Queues, timelines, recent items
Sets: Unique items, tags, relationships
Sorted Sets: Leaderboards, priority queues, time-series
Bitmaps: Boolean flags, analytics
HyperLogLog: Cardinality estimation
Geospatial: Location-based queries
Streams: Event logs, message queues

#2. Implementasikan Cache Warming

Pre-populate cache untuk frequently accessed data.

async warmCache() {
  const popularPosts = await db.getPopularPosts(100);
  
  for (const post of popularPosts) {
    await redis.setex(
      `post:${post.id}`,
      3600,
      JSON.stringify(post)
    );
  }
}

#3. Gunakan Pipelining untuk Bulk Operations

Kurangi network round trips dengan pipelining.

// ❌ Lambat - multiple round trips
for (const post of posts) {
  await redis.set(`post:${post.id}`, JSON.stringify(post));
}
 
// ✅ Cepat - single round trip
const pipeline = redis.pipeline();
for (const post of posts) {
  pipeline.set(`post:${post.id}`, JSON.stringify(post));
}
await pipeline.exec();

#4. Implementasikan Graceful Degradation

Aplikasi harus bekerja meskipun Redis down.

async getPost(id: string) {
  try {
    const cached = await redis.get(`post:${id}`);
    if (cached) return JSON.parse(cached);
  } catch (err) {
    logger.warn('Redis unavailable, falling back to DB');
  }
  
  // Fallback ke database
  return db.getPost(id);
}

#5. Monitor Key Metrics

Track Redis performance:

Hit rate (cache hits / total requests)
Memory usage
Evicted keys
Connection count
Command latency

async getMetrics() {
  const info = await redis.info();
  return {
    hitRate: calculateHitRate(info),
    memoryUsed: parseMemory(info),
    evictedKeys: parseEvicted(info),
  };
}

#Kapan TIDAK Menggunakan Redis

#1. Primary Data Store untuk Critical Data

Redis bukan pengganti traditional databases. Gunakan untuk:

Caching
Session storage
Real-time analytics
Message queues

Tapi tidak untuk:

Financial transactions
User credentials (gunakan proper database)
Data yang memerlukan complex queries

#2. Large Dataset Storage

Redis menyimpan semuanya di RAM. Jika dataset Anda lebih besar dari available memory, pertimbangkan:

PostgreSQL dengan proper indexing
Elasticsearch untuk search
MongoDB untuk document storage

#3. Complex Relationships

Redis tidak mendukung joins atau complex queries. Untuk relational data, gunakan:

PostgreSQL
MySQL
Relational databases dengan proper schema

#4. Compliance Requirements

Jika Anda memerlukan ACID guarantees, audit logs, atau strict consistency, gunakan traditional databases.

#Kesimpulan

Redis adalah tool yang powerful ketika digunakan dengan benar. Memahami tipe data dan use case mereka memungkinkan Anda membangun sistem high-performance dan scalable. Contoh NestJS mendemonstrasikan pola real-world:

Session management dengan automatic expiration
Multi-layer caching dengan invalidation
Rate limiting dengan atomic operations
Real-time analytics dengan sorted sets
Graceful error handling

Mulai dengan use case sederhana seperti caching dan session storage. Seiring Anda mendapatkan confidence, eksplorasi pola advanced seperti pub/sub, streams, dan geospatial queries. Simplicity dan performance Redis membuatnya indispensable dalam arsitektur modern.

Langkah selanjutnya:

Setup Redis locally dengan Docker
Implementasikan caching di existing API Anda
Tambahkan session management
Eksperimen dengan different data types
Monitor performance dan optimize

Redis bukan hanya cache—ini adalah data structure server yang dapat mentransformasi performance dan capabilities aplikasi Anda.

Fundamental Redis - Tipe Data, Use Case, dan Membangun API NestJS Real-World

Related Posts