NestJS의 고급 캐싱으로 속도 및 성능 향상: AVL 트리 및 Redis를 사용하는 방법

요청에 응답하는 속도와 효율성은 대규모 및 트래픽이 많은 시스템에서 가장 중요합니다. 전자상거래 웹사이트, 소셜 네트워크, 은행 서비스와 같은 온라인 플랫폼은 엄청난 양의 데이터와 사용자 요청에 직면해 있습니다. 이러한 높은 수요는 서버와 데이터베이스에 상당한 부하를 줄 뿐만 아니라 사용자 경험에도 큰 영향을 미칠 수 있습니다. 이러한 맥락에서 캐싱 시스템을 구현하는 것은 성능을 향상하고 리소스 부하를 줄이는 효과적인 솔루션이 될 수 있습니다.

이 기사에서는 AVL 트리와 Redis를 결합한 고급 캐싱 시스템의 구현을 살펴봅니다. 이 시스템에는 보안 메커니즘, TTL(Time to Live) 관리, Redis와의 통합이 포함되어 성능과 유연성을 향상시킵니다. 목표는 두 기술의 장점을 활용하면서 약점을 완화하는 것입니다.

중요사항: 이 글은 인공지능의 도움을 받아 작성되었습니다.

---

AVL 트리 기반 캐싱 시스템과 Redis 결합의 장점과 단점

장점:

1. 향상된 메모리 효율성:

   • 지능형 TTL 관리: AVL 트리를 사용하여 데이터 만료를 관리함으로써 메모리 소비를 최적화하고 오래된 데이터의 보존을 방지할 수 있습니다. 이는 데이터가 빠르게 변경되고 정확한 만료가 필요한 시나리오에서 특히 유용합니다.

2. 보안 강화:

   • 토큰 검증: 토큰 기반 검증 메커니즘을 추가하면 Redis 보안이 강화됩니다. 이러한 추가 보안 계층은 캐시에 대한 무단 액세스를 방지하여 전반적인 시스템 보안을 강화합니다.

3. 고급 TTL 관리:

   • 사용자 정의 만료 정책: AVL 트리를 사용하면 Redis가 기본적으로 지원하지 않을 수 있는 더 복잡하고 맞춤화된 만료 정책을 구현할 수 있습니다.

4. 다양한 데이터 구조:

   • 균형 트리 구조: 균형 잡힌 데이터 구조인 AVL 트리는 Redis의 기본 데이터 구조에 비해 빠른 검색과 정렬이 필요한 특정 사용 사례에 더 나은 성능을 제공할 수 있습니다.

5. 향상된 유연성 및 사용자 정의:

   • 더욱 뛰어난 맞춤화: 두 시스템을 결합하면 더 광범위한 맞춤화가 가능해 더욱 정밀하고 애플리케이션별 솔루션을 개발할 수 있습니다.

단점:

1. 건축 복잡성 증가:

   • 두 개의 캐싱 시스템 관리: Redis와 AVL 트리 기반 캐싱 시스템을 동시에 사용하면 아키텍처가 복잡해지고 두 시스템 간의 조화로운 관리가 필요합니다.

2. 오버헤드 시간 증가:

   • 추가 지연 시간: 추가 캐싱 계층을 추가하면 지연이 발생할 수 있습니다. 이러한 잠재적인 지연보다 성능상의 이점이 더 큰지 확인하는 것이 중요합니다.

3. 데이터 유지 관리 및 동기화:

   • 데이터 일관성: 복잡한 동기화 메커니즘이 필요한 데이터 불일치를 방지하려면 Redis와 AVL 트리 간의 일관성과 동기화를 유지하는 것이 중요합니다.

4. 높은 개발 및 유지 관리 비용:

   • 비용 증가: 두 개의 캐싱 시스템을 개발하고 유지하려면 더 많은 리소스와 다양한 전문 지식이 필요하므로 전체 프로젝트 비용이 증가할 수 있습니다.

5. 보안 복잡성:

   • 보안 정책 조정: 보안 정책이 두 시스템 전반에 걸쳐 올바르고 일관되게 구현되도록 보장하는 것이 어려울 수 있습니다.

---

AVL 트리와 Redis를 이용한 캐싱 시스템 구현

아래에서는 이 캐싱 시스템의 전문적인 구현을 소개합니다. 이 구현에는 TTL 기능으로 데이터를 관리하기 위한 AVL 트리와 빠른 데이터 저장을 위한 Redis가 포함됩니다.

1. TTL이 포함된 AVL 트리

먼저 TTL 관리 기능을 갖춘 AVL 트리를 구현합니다.

// src/utils/avltree.ts

export class AVLNode {
  key: string;
  value: any;
  ttl: number; // Expiration time in milliseconds
  height: number;
  left: AVLNode | null;
  right: AVLNode | null;

  constructor(key: string, value: any, ttl: number) {
    this.key = key;
    this.value = value;
    this.ttl = Date.now() + ttl;
    this.height = 1;
    this.left = null;
    this.right = null;
  }

  isExpired(): boolean {
    return Date.now() > this.ttl;
  }
}

export class AVLTree {
  private root: AVLNode | null;

  constructor() {
    this.root = null;
  }

  private getHeight(node: AVLNode | null): number {
    return node ? node.height : 0;
  }

  private updateHeight(node: AVLNode): void {
    node.height = 1 + Math.max(this.getHeight(node.left), this.getHeight(node.right));
  }

  private rotateRight(y: AVLNode): AVLNode {
    const x = y.left!;
    y.left = x.right;
    x.right = y;
    this.updateHeight(y);
    this.updateHeight(x);
    return x;
  }

  private rotateLeft(x: AVLNode): AVLNode {
    const y = x.right!;
    x.right = y.left;
    y.left = x;
    this.updateHeight(x);
    this.updateHeight(y);
    return y;
  }

  private getBalance(node: AVLNode): number {
    return node ? this.getHeight(node.left) - this.getHeight(node.right) : 0;
  }

  insert(key: string, value: any, ttl: number): void {
    this.root = this.insertNode(this.root, key, value, ttl);
  }

  private insertNode(node: AVLNode | null, key: string, value: any, ttl: number): AVLNode {
    if (!node) return new AVLNode(key, value, ttl);

    if (key < node.key) {
      node.left = this.insertNode(node.left, key, value, ttl);
    } else if (key > node.key) {
      node.right = this.insertNode(node.right, key, value, ttl);
    } else {
      node.value = value;
      node.ttl = Date.now() + ttl;
      return node;
    }

    this.updateHeight(node);
    const balance = this.getBalance(node);

    // Balancing the tree
    if (balance > 1 && key < node.left!.key) return this.rotateRight(node);
    if (balance < -1 && key > node.right!.key) return this.rotateLeft(node);
    if (balance > 1 && key > node.left!.key) {
      node.left = this.rotateLeft(node.left!);
      return this.rotateRight(node);
    }
    if (balance < -1 && key < node.right!.key) {
      node.right = this.rotateRight(node.right!);
      return this.rotateLeft(node);
    }

    return node;
  }

  search(key: string): any {
    let node = this.root;
    while (node) {
      if (node.isExpired()) {
        this.delete(key);
        return null;
      }
      if (key === node.key) return node.value;
      node = key < node.key ? node.left : node.right;
    }
    return null;
  }

  delete(key: string): void {
    this.root = this.deleteNode(this.root, key);
  }

  private deleteNode(node: AVLNode | null, key: string): AVLNode | null {
    if (!node) return null;

    if (key < node.key) {
      node.left = this.deleteNode(node.left, key);
    } else if (key > node.key) {
      node.right = this.deleteNode(node.right, key);
    } else {
      if (!node.left || !node.right) return node.left || node.right;
      let minLargerNode = node.right;
      while (minLargerNode.left) minLargerNode = minLargerNode.left;
      node.key = minLargerNode.key;
      node.value = minLargerNode.value;
      node.ttl = minLargerNode.ttl;
      node.right = this.deleteNode(node.right, minLargerNode.key);
    }

    this.updateHeight(node);
    const balance = this.getBalance(node);

    if (balance > 1 && this.getBalance(node.left!) >= 0) return this.rotateRight(node);
    if (balance < -1 && this.getBalance(node.right!) <= 0) return this.rotateLeft(node);
    if (balance > 1 && this.getBalance(node.left!) < 0) {
      node.left = this.rotateLeft(node.left!);
      return this.rotateRight(node);
    }
    if (balance < -1 && this.getBalance(node.right!) > 0) {
      node.right = this.rotateRight(node.right!);
      return this.rotateLeft(node);
    }

    return node;
  }
}

2. Redis 통합을 통한 캐시 서비스(CacheService)

이 섹션에서는 캐시 관리를 위해 AVL 트리와 Redis를 모두 활용하는 캐시 서비스를 구현합니다. 또한 토큰 검증 메커니즘을 통합합니다.

// src/cache/cache.service.ts

import { Injectable, UnauthorizedException, InternalServerErrorException } from '@nestjs/common';
import { AVLTree } from '../utils/avltree';
import { InjectRedis, Redis } from '@nestjs-modules/ioredis';

@Injectable()
export class CacheService {
  private avlTree: AVLTree;
  private authorizedTokens: Set<string> = new Set(['your_authorized_token']); // Authorized tokens

  constructor(@InjectRedis() private readonly redis: Redis) {
    this.avlTree = new AVLTree();
  }

  validateToken(token: string): void {
    if (!this.authorizedTokens.has(token)) {
      throw new UnauthorizedException('Invalid access token');
    }
  }

  async set(key: string, value: any, ttl: number, token: string): Promise<void> {
    this.validateToken(token);
    try {
      // Store in Redis
      await this.redis.set(key, JSON.stringify(value), 'PX', ttl);
      // Store in AVL Tree
      this.avlTree.insert(key, value, ttl);
    } catch (error) {
      throw new InternalServerErrorException('Failed to set cache');
    }
  }

  async get(key: string, token: string): Promise<any> {
    this.validateToken(token);
    try {
      // First, attempt to retrieve from Redis
      const redisValue = await this.redis.get(key);
      if (redisValue) {
        return JSON.parse(redisValue);
      }

      // If not found in Redis, retrieve from AVL Tree
      const avlValue = this.avlTree.search(key);
      if (avlValue) {
        // Re-store in Redis for faster access next time
        // Assuming the remaining TTL is maintained in AVL Tree
        // For simplicity, we set a new TTL
        const newTtl = 60000; // 60 seconds as an example
        await this.redis.set(key, JSON.stringify(avlValue), 'PX', newTtl);
        return avlValue;
      }

      return null;
    } catch (error) {
      throw new InternalServerErrorException('Failed to get cache');
    }
  }

  async delete(key: string, token: string): Promise<void> {
    this.validateToken(token);
    try {
      // Remove from Redis
      await this.redis.del(key);
      // Remove from AVL Tree
      this.avlTree.delete(key);
    } catch (error) {
      throw new InternalServerErrorException('Failed to delete cache');
    }
  }
}

3. API 컨트롤러(CacheController)

컨트롤러는 캐시 서비스에 대한 API 요청을 관리합니다.

// src/cache/cache.controller.ts

import { Controller, Get, Post, Delete, Body, Param, Query, HttpCode, HttpStatus } from '@nestjs/common';
import { CacheService } from './cache.service';

class SetCacheDto {
  key: string;
  value: any;
  ttl: number; // milliseconds
  token: string;
}

@Controller('cache')
export class CacheController {
  constructor(private readonly cacheService: CacheService) {}

  @Post('set')
  @HttpCode(HttpStatus.CREATED)
  async setCache(@Body() body: SetCacheDto) {
    await this.cacheService.set(body.key, body.value, body.ttl, body.token);
    return { message: 'Data cached successfully' };
  }

  @Get('get/:key')
  async getCache(@Param('key') key: string, @Query('token') token: string) {
    const value = await this.cacheService.get(key, token);
    return value ? { value } : { message: 'Key not found or expired' };
  }

  @Delete('delete/:key')
  @HttpCode(HttpStatus.NO_CONTENT)
  async deleteCache(@Param('key') key: string, @Query('token') token: string) {
    await this.cacheService.delete(key, token);
    return { message: 'Key deleted successfully' };
  }
}

4. 캐시 모듈(CacheModule)

서비스와 컨트롤러를 연결하고 Redis를 주입하는 캐시 모듈을 정의합니다.

// src/cache/cache.module.ts

import { Module } from '@nestjs/common';
import { CacheService } from './cache.service';
import { CacheController } from './cache.controller';
import { RedisModule } from '@nestjs-modules/ioredis';

@Module({
  imports: [
    RedisModule.forRoot({
      config: {
        host: 'localhost',
        port: 6379,
        // Other Redis configurations
      },
    }),
  ],
  providers: [CacheService],
  controllers: [CacheController],
})
export class CacheModule {}

5. 레디스 구성

NestJS 프로젝트에서 Redis를 사용하기 위해 @nestjs-modules/ioredis 패키지를 활용합니다. 먼저 패키지를 설치하세요.

npm install @nestjs-modules/ioredis ioredis

그런 다음 위와 같이 CacheModule에서 Redis를 구성합니다. 더 고급 구성이 필요한 경우 별도의 구성 파일을 사용할 수 있습니다.

6. 토큰 검증 메커니즘

토큰을 관리하고 검증하기 위해 다양한 전략을 사용할 수 있습니다. 이 간단한 구현에서는 토큰이 고정된 세트로 유지됩니다. 대규모 프로젝트의 경우 JWT(JSON 웹 토큰) 또는 기타 고급 보안 방법을 사용하는 것이 좋습니다.

7. 오류 처리 및 입력 유효성 검사

이 구현에서는 입력 유효성 검사 및 오류 관리에 DTO(Data Transfer Object) 클래스가 사용됩니다. 또한 캐시 서비스는 일반적인 오류 처리를 활용하여 예상치 못한 문제를 방지합니다.

8. 메인 애플리케이션 모듈(AppModule)

마지막으로 기본 애플리케이션 모듈에 캐시 모듈을 추가합니다.

// src/utils/avltree.ts

export class AVLNode {
  key: string;
  value: any;
  ttl: number; // Expiration time in milliseconds
  height: number;
  left: AVLNode | null;
  right: AVLNode | null;

  constructor(key: string, value: any, ttl: number) {
    this.key = key;
    this.value = value;
    this.ttl = Date.now() + ttl;
    this.height = 1;
    this.left = null;
    this.right = null;
  }

  isExpired(): boolean {
    return Date.now() > this.ttl;
  }
}

export class AVLTree {
  private root: AVLNode | null;

  constructor() {
    this.root = null;
  }

  private getHeight(node: AVLNode | null): number {
    return node ? node.height : 0;
  }

  private updateHeight(node: AVLNode): void {
    node.height = 1 + Math.max(this.getHeight(node.left), this.getHeight(node.right));
  }

  private rotateRight(y: AVLNode): AVLNode {
    const x = y.left!;
    y.left = x.right;
    x.right = y;
    this.updateHeight(y);
    this.updateHeight(x);
    return x;
  }

  private rotateLeft(x: AVLNode): AVLNode {
    const y = x.right!;
    x.right = y.left;
    y.left = x;
    this.updateHeight(x);
    this.updateHeight(y);
    return y;
  }

  private getBalance(node: AVLNode): number {
    return node ? this.getHeight(node.left) - this.getHeight(node.right) : 0;
  }

  insert(key: string, value: any, ttl: number): void {
    this.root = this.insertNode(this.root, key, value, ttl);
  }

  private insertNode(node: AVLNode | null, key: string, value: any, ttl: number): AVLNode {
    if (!node) return new AVLNode(key, value, ttl);

    if (key < node.key) {
      node.left = this.insertNode(node.left, key, value, ttl);
    } else if (key > node.key) {
      node.right = this.insertNode(node.right, key, value, ttl);
    } else {
      node.value = value;
      node.ttl = Date.now() + ttl;
      return node;
    }

    this.updateHeight(node);
    const balance = this.getBalance(node);

    // Balancing the tree
    if (balance > 1 && key < node.left!.key) return this.rotateRight(node);
    if (balance < -1 && key > node.right!.key) return this.rotateLeft(node);
    if (balance > 1 && key > node.left!.key) {
      node.left = this.rotateLeft(node.left!);
      return this.rotateRight(node);
    }
    if (balance < -1 && key < node.right!.key) {
      node.right = this.rotateRight(node.right!);
      return this.rotateLeft(node);
    }

    return node;
  }

  search(key: string): any {
    let node = this.root;
    while (node) {
      if (node.isExpired()) {
        this.delete(key);
        return null;
      }
      if (key === node.key) return node.value;
      node = key < node.key ? node.left : node.right;
    }
    return null;
  }

  delete(key: string): void {
    this.root = this.deleteNode(this.root, key);
  }

  private deleteNode(node: AVLNode | null, key: string): AVLNode | null {
    if (!node) return null;

    if (key < node.key) {
      node.left = this.deleteNode(node.left, key);
    } else if (key > node.key) {
      node.right = this.deleteNode(node.right, key);
    } else {
      if (!node.left || !node.right) return node.left || node.right;
      let minLargerNode = node.right;
      while (minLargerNode.left) minLargerNode = minLargerNode.left;
      node.key = minLargerNode.key;
      node.value = minLargerNode.value;
      node.ttl = minLargerNode.ttl;
      node.right = this.deleteNode(node.right, minLargerNode.key);
    }

    this.updateHeight(node);
    const balance = this.getBalance(node);

    if (balance > 1 && this.getBalance(node.left!) >= 0) return this.rotateRight(node);
    if (balance < -1 && this.getBalance(node.right!) <= 0) return this.rotateLeft(node);
    if (balance > 1 && this.getBalance(node.left!) < 0) {
      node.left = this.rotateLeft(node.left!);
      return this.rotateRight(node);
    }
    if (balance < -1 && this.getBalance(node.right!) > 0) {
      node.right = this.rotateRight(node.right!);
      return this.rotateLeft(node);
    }

    return node;
  }
}

9. 메인 애플리케이션 파일(main.ts)

NestJS를 부트스트랩하는 기본 애플리케이션 파일입니다.

// src/cache/cache.service.ts

import { Injectable, UnauthorizedException, InternalServerErrorException } from '@nestjs/common';
import { AVLTree } from '../utils/avltree';
import { InjectRedis, Redis } from '@nestjs-modules/ioredis';

@Injectable()
export class CacheService {
  private avlTree: AVLTree;
  private authorizedTokens: Set<string> = new Set(['your_authorized_token']); // Authorized tokens

  constructor(@InjectRedis() private readonly redis: Redis) {
    this.avlTree = new AVLTree();
  }

  validateToken(token: string): void {
    if (!this.authorizedTokens.has(token)) {
      throw new UnauthorizedException('Invalid access token');
    }
  }

  async set(key: string, value: any, ttl: number, token: string): Promise<void> {
    this.validateToken(token);
    try {
      // Store in Redis
      await this.redis.set(key, JSON.stringify(value), 'PX', ttl);
      // Store in AVL Tree
      this.avlTree.insert(key, value, ttl);
    } catch (error) {
      throw new InternalServerErrorException('Failed to set cache');
    }
  }

  async get(key: string, token: string): Promise<any> {
    this.validateToken(token);
    try {
      // First, attempt to retrieve from Redis
      const redisValue = await this.redis.get(key);
      if (redisValue) {
        return JSON.parse(redisValue);
      }

      // If not found in Redis, retrieve from AVL Tree
      const avlValue = this.avlTree.search(key);
      if (avlValue) {
        // Re-store in Redis for faster access next time
        // Assuming the remaining TTL is maintained in AVL Tree
        // For simplicity, we set a new TTL
        const newTtl = 60000; // 60 seconds as an example
        await this.redis.set(key, JSON.stringify(avlValue), 'PX', newTtl);
        return avlValue;
      }

      return null;
    } catch (error) {
      throw new InternalServerErrorException('Failed to get cache');
    }
  }

  async delete(key: string, token: string): Promise<void> {
    this.validateToken(token);
    try {
      // Remove from Redis
      await this.redis.del(key);
      // Remove from AVL Tree
      this.avlTree.delete(key);
    } catch (error) {
      throw new InternalServerErrorException('Failed to delete cache');
    }
  }
}

10. 애플리케이션 테스트 및 실행

모든 구성 요소를 구현한 후 애플리케이션을 실행하여 기능을 확인할 수 있습니다.

// src/cache/cache.controller.ts

import { Controller, Get, Post, Delete, Body, Param, Query, HttpCode, HttpStatus } from '@nestjs/common';
import { CacheService } from './cache.service';

class SetCacheDto {
  key: string;
  value: any;
  ttl: number; // milliseconds
  token: string;
}

@Controller('cache')
export class CacheController {
  constructor(private readonly cacheService: CacheService) {}

  @Post('set')
  @HttpCode(HttpStatus.CREATED)
  async setCache(@Body() body: SetCacheDto) {
    await this.cacheService.set(body.key, body.value, body.ttl, body.token);
    return { message: 'Data cached successfully' };
  }

  @Get('get/:key')
  async getCache(@Param('key') key: string, @Query('token') token: string) {
    const value = await this.cacheService.get(key, token);
    return value ? { value } : { message: 'Key not found or expired' };
  }

  @Delete('delete/:key')
  @HttpCode(HttpStatus.NO_CONTENT)
  async deleteCache(@Param('key') key: string, @Query('token') token: string) {
    await this.cacheService.delete(key, token);
    return { message: 'Key deleted successfully' };
  }
}

11. 샘플 요청

캐시 설정:

// src/cache/cache.module.ts

import { Module } from '@nestjs/common';
import { CacheService } from './cache.service';
import { CacheController } from './cache.controller';
import { RedisModule } from '@nestjs-modules/ioredis';

@Module({
  imports: [
    RedisModule.forRoot({
      config: {
        host: 'localhost',
        port: 6379,
        // Other Redis configurations
      },
    }),
  ],
  providers: [CacheService],
  controllers: [CacheController],
})
export class CacheModule {}

캐시 가져오기:

npm install @nestjs-modules/ioredis ioredis

캐시 삭제:

// src/app.module.ts

import { Module } from '@nestjs/common';
import { CacheModule } from './cache/cache.module';

@Module({
  imports: [CacheModule],
  controllers: [],
  providers: [],
})
export class AppModule {}

---

Redis와 AVL 트리 기반 캐싱 시스템을 결합하는 데 적합한 사용 사례

1. 은행 및 금융 시스템:

   • 민감한 세션 및 거래 관리: 민감한 금융 데이터에는 높은 보안과 정확한 TTL 관리가 필수적입니다. 토큰 보안과 지능형 TTL 관리를 결합하면 이 분야에서 매우 유용합니다.

2. 트래픽이 많은 전자상거래 플랫폼:

   • 제품 데이터 저장 및 장바구니 관리: Amazon과 같은 대규모 온라인 상점에서 사용자 경험을 향상하려면 메모리 최적화와 데이터 액세스 속도 향상이 중요합니다.

3. 메시징 및 소셜 네트워킹 애플리케이션:

   • 실시간 사용자 상태 저장: 사용자의 온라인/오프라인 상태와 메시지를 표시하기 위해서는 빠른 접근과 정확한 데이터 관리가 필요합니다.

4. 날씨 및 환율 애플리케이션:

   • 요청 부하를 줄이기 위한 API 캐싱: 정확한 만료 관리로 복잡한 계산 결과와 라이브 데이터를 저장하여 사용자에게 최신 정보를 빠르게 제공합니다.

5. 콘텐츠 관리 시스템 및 미디어 플랫폼:

   • 트래픽이 많은 페이지 및 콘텐츠 캐싱: 조회수가 높은 콘텐츠에 대한 액세스를 최적화하고 서버 부하를 줄여 보다 원활한 사용자 경험을 제공합니다.

6. 분석 애플리케이션 및 실시간 대시보드:

   • 즉각적인 분석 결과 저장: 다중 캐시를 활용하여 빠르고 최신의 분석 데이터를 제공하여 성능과 결과 정확도를 향상시킵니다.

---

결론

이 기사에서는 NestJS 프레임워크 내에서 AVL 트리와 Redis를 사용하여 고급 캐싱 시스템을 구현했습니다. 고급 TTL 관리, 토큰 기반 보안 및 Redis 통합을 제공하는 이 시스템은 수요가 많은 애플리케이션을 위한 강력하고 유연한 솔루션을 제공합니다. 이 두 기술의 결합은 두 기술의 장점을 모두 활용하여 Redis의 약점을 해결하고 전반적인 캐싱 성능을 향상시킵니다.

위 내용은 NestJS의 고급 캐싱으로 속도 및 성능 향상: AVL 트리 및 Redis를 사용하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!