Database Indexing 최적화 전략: Node.js Backend 성능 향상 가이드

데이터베이스 성능은 백엔드 시스템의 핵심 요소입니다. 특히 대용량 데이터를 다루는 Node.js 애플리케이션에서는 적절한 인덱싱 전략이 API 응답 시간과 전체 시스템 성능을 크게 좌우합니다. 이 글에서는 효과적인 데이터베이스 인덱싱 최적화 전략과 실전 적용 방법을 상세히 살펴보겠습니다.

인덱싱의 기본 개념과 중요성

데이터베이스 인덱스는 책의 색인과 같은 역할을 합니다. 특정 데이터를 빠르게 찾기 위한 별도의 자료구조로, 테이블의 특정 컬럼에 대한 포인터 정보를 저장합니다.

인덱스가 없는 경우 데이터베이스는 전체 테이블을 스캔(Full Table Scan)해야 하지만, 적절한 인덱스가 있다면 B-Tree 구조를 통해 O(log n) 시간 복잡도로 데이터에 접근할 수 있습니다.

// 인덱스가 없는 경우의 쿼리 성능
const users = await User.find({ email: 'user@example.com' });
// 실행 시간: ~500ms (100만 레코드 기준)

// 이메일 필드에 인덱스가 있는 경우
db.users.createIndex({ email: 1 });
const users = await User.find({ email: 'user@example.com' });
// 실행 시간: ~5ms

Node.js 환경에서의 인덱스 전략

Node.js 백엔드에서는 주로 MongoDB와 MySQL을 사용하며, 각각 다른 인덱싱 접근법이 필요합니다.

MongoDB 인덱싱 전략

MongoDB에서는 다양한 인덱스 타입을 제공합니다:

// 단일 필드 인덱스
db.users.createIndex({ userId: 1 });

// 복합 인덱스 (순서가 중요)
db.orders.createIndex({ userId: 1, createdAt: -1 });

// 텍스트 검색 인덱스
db.posts.createIndex({ title: "text", content: "text" });

// 부분 인덱스 (조건부)
db.users.createIndex(
  { email: 1 },
  { partialFilterExpression: { email: { $exists: true } } }
);

MySQL 인덱싱 전략

MySQL에서는 InnoDB 엔진 기준으로 다음과 같은 인덱스 전략을 사용합니다:

-- 기본 인덱스
CREATE INDEX idx_user_email ON users(email);

-- 복합 인덱스
CREATE INDEX idx_order_user_date ON orders(user_id, created_at);

-- 커버링 인덱스
CREATE INDEX idx_user_profile ON users(id, email, name, created_at);

-- 함수 기반 인덱스 (MySQL 8.0+)
CREATE INDEX idx_user_email_lower ON users((LOWER(email)));

쿼리 패턴 분석과 인덱스 설계

효과적인 인덱스 설계를 위해서는 애플리케이션의 쿼리 패턴을 먼저 분석해야 합니다.

쿼리 패턴 분석 방법

// Express.js 미들웨어로 쿼리 로깅
const queryLogger = (req, res, next) => {
  const startTime = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - startTime;
    console.log({
      method: req.method,
      url: req.url,
      duration: `${duration}ms`,
      query: req.query
    });
  });
  
  next();
};

app.use(queryLogger);

실전 인덱스 설계 예제

사용자 관리 시스템을 예로 들어보겠습니다:

// User 스키마 (MongoDB Mongoose)
const userSchema = new mongoose.Schema({
  email: { type: String, required: true, unique: true },
  username: { type: String, required: true },
  status: { type: String, enum: ['active', 'inactive', 'suspended'] },
  createdAt: { type: Date, default: Date.now },
  lastLoginAt: { type: Date },
  profile: {
    firstName: String,
    lastName: String,
    age: Number
  }
});

// 주요 쿼리 패턴 기반 인덱스 설계
userSchema.index({ email: 1 }); // 로그인 쿼리
userSchema.index({ username: 1 }); // 사용자명 검색
userSchema.index({ status: 1, createdAt: -1 }); // 상태별 최신 사용자 조회
userSchema.index({ 'profile.age': 1 }); // 나이 기반 검색
userSchema.index({ lastLoginAt: -1 }, { sparse: true }); // 최근 로그인 사용자

복합 인덱스 최적화 기법

복합 인덱스는 여러 필드를 조합한 인덱스로, 필드 순서가 성능에 큰 영향을 미칩니다.

ESR 규칙 (Equality, Sort, Range)

복합 인덱스 필드 순서를 결정할 때 사용하는 규칙입니다:

// 쿼리 예시
db.orders.find({ 
  status: 'completed',           // Equality
  userId: { $in: [1, 2, 3] }     // Range
}).sort({ createdAt: -1 });      // Sort

// 최적 인덱스 순서: Equality → Sort → Range
db.orders.createIndex({ status: 1, createdAt: -1, userId: 1 });

인덱스 프리픽스 활용

// 복합 인덱스
db.products.createIndex({ category: 1, brand: 1, price: 1 });

// 다음 쿼리들이 모두 인덱스를 활용 가능
// 1. { category: 'electronics' }
// 2. { category: 'electronics', brand: 'samsung' }
// 3. { category: 'electronics', brand: 'samsung', price: { $lt: 1000 } }

// 하지만 이 쿼리는 인덱스를 제대로 활용하지 못함
// { brand: 'samsung', price: { $lt: 1000 } }

인덱스 성능 모니터링과 분석

MongoDB 성능 분석

// 쿼리 실행 계획 분석
const explain = await db.users.find({ email: 'test@example.com' }).explain('executionStats');

console.log({
  executionTimeMillis: explain.executionStats.executionTimeMillis,
  totalDocsExamined: explain.executionStats.totalDocsExamined,
  totalDocsReturned: explain.executionStats.totalDocsReturned,
  indexUsed: explain.executionStats.executionStages.indexName
});

MySQL 성능 분석

-- 쿼리 실행 계획 확인
EXPLAIN SELECT * FROM users WHERE email = 'test@example.com';

-- 인덱스 사용량 통계
SELECT 
  TABLE_NAME,
  INDEX_NAME,
  CARDINALITY,
  SUB_PART,
  NULLABLE
FROM information_schema.STATISTICS 
WHERE TABLE_SCHEMA = 'your_database';

Node.js 애플리케이션에서의 인덱스 관리

동적 인덱스 생성

class IndexManager {
  constructor(db) {
    this.db = db;
    this.indexCache = new Map();
  }

  async createIndexIfNotExists(collection, indexSpec, options = {}) {
    const indexKey = JSON.stringify({ collection, indexSpec });
    
    if (this.indexCache.has(indexKey)) {
      return;
    }

    try {
      await this.db.collection(collection).createIndex(indexSpec, options);
      this.indexCache.set(indexKey, true);
      console.log(`Index created: ${collection}`, indexSpec);
    } catch (error) {
      if (error.code !== 85) { // Index already exists
        throw error;
      }
    }
  }

  async optimizeCollection(collection, queryPatterns) {
    for (const pattern of queryPatterns) {
      await this.createIndexIfNotExists(collection, pattern.index, pattern.options);
    }
  }
}

인덱스 성능 모니터링 서비스

class IndexMonitor {
  constructor(db) {
    this.db = db;
    this.slowQueries = [];
  }

  startMonitoring() {
    setInterval(async () => {
      await this.checkSlowQueries();
      await this.analyzeIndexUsage();
    }, 60000); // 1분마다 체크
  }

  async checkSlowQueries() {
    // MongoDB의 경우 프로파일러 사용
    const slowQueries = await this.db.collection('system.profile')
      .find({ ts: { $gte: new Date(Date.now() - 60000) }, millis: { $gte: 100 } })
      .toArray();

    if (slowQueries.length > 0) {
      console.warn(`Found ${slowQueries.length} slow queries in the last minute`);
      this.slowQueries.push(...slowQueries);
    }
  }

  async analyzeIndexUsage() {
    const stats = await this.db.collection('users').aggregate([
      { $indexStats: {} }
    ]).toArray();

    const unusedIndexes = stats.filter(stat => stat.accesses.ops === 0);
    if (unusedIndexes.length > 0) {
      console.log('Unused indexes found:', unusedIndexes.map(idx => idx.name));
    }
  }
}

인덱스 최적화 모범 사례

1. 선택적 인덱싱

// 좋은 예: 높은 선택성을 가진 필드
userSchema.index({ email: 1 }); // 각 이메일은 고유함

// 나쁜 예: 낮은 선택성을 가진 필드
userSchema.index({ gender: 1 }); // 대부분 'M' 또는 'F' 값만 가짐

2. 부분 인덱스 활용

// 활성 사용자만 인덱싱
userSchema.index(
  { lastLoginAt: -1 },
  { 
    partialFilterExpression: { 
      status: 'active',
      lastLoginAt: { $exists: true }
    }
  }
);

3. TTL 인덱스로 자동 정리

// 30일 후 자동 삭제되는 세션 데이터
sessionSchema.index(
  { createdAt: 1 },
  { expireAfterSeconds: 2592000 } // 30일
);

아키텍처 레벨에서의 인덱싱 전략

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Client App    │    │   Load Balancer │    │   API Gateway   │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         └───────────────────────┼───────────────────────┘
                                 │
         ┌───────────────────────┼───────────────────────┐
         │                       │                       │
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Node.js App   │    │   Node.js App   │    │   Node.js App   │
│   (Read Heavy)  │    │   (Write Heavy) │    │  (Analytics)    │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  Read Replica   │    │  Master DB      │    │  Data Warehouse │
│ (많은 인덱스)    │    │ (최소 인덱스)    │    │ (집계 인덱스)    │
└─────────────────┘    └─────────────────┘    └─────────────────┘

읽기 전용 복제본에는 많은 인덱스를 생성하여 조회 성능을 최적화하고, 마스터 데이터베이스에는 쓰기 성능을 위해 필수 인덱스만 유지하는 전략을 사용할 수 있습니다.

마무리

데이터베이스 인덱싱 최적화는 Node.js 백엔드 성능 향상의 핵심 요소입니다. 애플리케이션의 쿼리 패턴을 정확히 분석하고, 적절한 인덱스 전략을 수립하며, 지속적인 모니터링을 통해 성능을 개선해 나가는 것이 중요합니다. 특히 복합 인덱스의 필드 순서와 부분 인덱스 활용을 통해 더욱 효율적인 데이터베이스 운영이 가능합니다.