ドキュメント価格ブログ
お問い合わせ
ログイン無料で新規登録
Back to Tech Articles

Redis를 사용하여 데이터베이스 성능 최적화: 캐시 키 디자인 및 무효화 전략

9月 30, 2025
# Misc

James Reed

Infrastructure Engineer · Leapcell

この記事はEnglish、日本語、Deutschでも利用できます
Cover of "Redis를 사용하여 데이터베이스 성능 최적화: 캐시 키 디자인 및 무효화 전략"

소개

현대의 데이터 중심 애플리케이션에서 사용자 트래픽과 데이터 볼륨이 증가함에 따라 데이터베이스 성능은 종종 병목 현상이 됩니다. 모든 요청에 대해, 특히 자주 액세스되거나 계산이 많이 필요한 쿼리의 경우 데이터베이스에서 직접 데이터를 검색하면 높은 지연 시간과 과도한 리소스 소비로 이어질 수 있습니다. 이것이 캐싱 메커니즘이 필수 불가결한 이유입니다.

Redis와 같이 빠르고 인메모리인 데이터 저장소에 일반 쿼리 결과를 저장함으로써 기본 데이터베이스의 부하를 크게 줄이고 응답 시간을 개선하며 전반적인 애플리케이션 확장성을 향상시킬 수 있습니다. 그러나 단순히 아키텍처에 캐시를 추가하는 것만으로는 충분하지 않습니다. 캐싱의 진정한 힘은 지능적인 구현, 특히 캐시 키를 설계하고 무효화를 관리하는 방법에 있습니다. 잘 고려된 전략 없이는 캐시가 빠르게 최신이 아닌 데이터의 원천이 되거나 비효과적인 성능 부스터가 될 수 있습니다.

이 문서는 효과적인 Redis 쿼리 결과 캐싱의 핵심 원칙을 탐구하며, 성능 향상을 극대화하고 데이터 무결성을 유지하기 위해 강력한 캐시 키를 구성하고 지능적인 무효화 정책을 구현하는 데 중점을 둡니다.

핵심 개념

설계 및 전략의 세부 사항을 살펴보기 전에 논의의 중심이 될 몇 가지 주요 용어를 간략하게 정의해 보겠습니다.

  • 캐시 키 (Cache Key): 캐시에서 데이터를 저장하고 검색하는 데 사용되는 고유 식별자입니다. 캐시된 데이터의 주소와 같습니다. 잘 설계된 캐시 키는 관련 데이터를 쉽게 찾을 수 있도록 하고 충돌을 방지합니다.
  • 캐시 히트 (Cache Hit): 데이터 요청이 캐시에서 직접 처리되어 데이터베이스를 우회하는 경우 발생합니다. 이것이 바람직한 결과입니다.
  • 캐시 미스 (Cache Miss): 요청된 데이터를 캐시에서 찾을 수 없어 애플리케이션이 기본 데이터베이스에서 데이터를 가져와야 하는 경우 발생합니다.
  • 캐시 무효화 (Cache Invalidation): 캐시된 데이터를 제거하거나 최신이 아닌 것으로 표시하여 후속 요청이 최신 정보를 데이터베이스에서 가져오도록 하는 프로세스입니다. 잘못된 무효화 전략은 데이터 불일치를 초래할 수 있습니다.
  • 수명 (Time-To-Live, TTL): 캐시된 데이터가 자동으로 만료되어 캐시에서 제거되는 기간입니다. 일반적이지만 조감적인 무효화 메커니즘입니다.
  • 쓰기 통과 캐시 (Write-Through Cache): 데이터가 캐시와 기본 데이터베이스에 동시에 기록됩니다. 이는 일관성을 보장하지만 쓰기 작업에 지연 시간을 추가할 수 있습니다.
  • 쓰기 다시 캐시 (Write-Back Cache): 데이터는 처음에 캐시에만 기록되고 이후 비동기적으로 기본 데이터베이스에 기록됩니다. 쓰기 성능을 향상시키지만 데이터가 영구 저장되기 전에 캐시가 실패할 경우 데이터 손실 위험이 있습니다.
  • 룩사이드 캐시 (Look-Aside Cache): 쿼리 결과 캐싱에 가장 일반적인 패턴입니다. 애플리케이션은 먼저 캐시를 확인합니다. 미스가 발생하면 데이터베이스에서 데이터를 검색하여 캐시에 저장한 다음 반환합니다.

캐시 키 디자인

캐시의 효율성은 캐시 키 디자인에 크게 좌우됩니다. 좋은 캐시 키는 다음과 같아야 합니다.

  1. 고유성 (Unique): 나타내는 특정 쿼리 결과를 고유하게 식별해야 합니다.
  2. 결정론적 (Deterministic): 동일한 쿼리 매개변수가 주어지면 항상 동일한 키를 생성해야 합니다.
  3. 간결성 (Concise): 고유하더라도 너무 길면 안 됩니다. 긴 키는 더 많은 메모리를 소비하고 조회 시간을 약간 증가시킬 수 있습니다.
  4. 가독성 (Readable, 선택 사항이지만 유용): 어느 정도 사람이 읽을 수 있는 키는 디버깅과 모니터링에 도움이 될 수 있습니다.

쿼리 결과의 경우 캐시 키는 일반적으로 해당 쿼리 결과의 고유성을 정의하는 모든 매개변수를 캡슐화해야 합니다. 여기에는 쿼리 유형, 테이블 이름, 특정 WHERE 절 조건, ORDER BY 절, LIMIT/OFFSET 값 및 기타 관련 기준이 포함됩니다.

사용자 프로필을 가져오는 예제를 생각해 보겠습니다.

SELECT * FROM users WHERE id = :userId;

이것에 대한 간단한 캐시 키는 user:profile:{userId}일 수 있습니다.

이제 카테고리별로 필터링되고 가격별로 정렬된 페이지 매김된 제품 목록에 대한 더 복잡한 쿼리를 생각해 보겠습니다.

SELECT id, name, price FROM products 
WHERE category_id = :categoryId 
ORDER BY price ASC 
LIMIT :limit OFFSET :offset;

이 쿼리에 대한 강력한 캐시 키는 모든 정의 매개변수를 통합해야 합니다.

// 예시 캐시 키 구조
category:{categoryId}:products:sorted_by_price_asc:limit_{limit}:offset_{offset}

다음은 프로그래밍 언어(예: Python)에서 이러한 키를 구성하는 방법입니다.

import hashlib
import json

def generate_product_cache_key(category_id, limit, offset):
    """
    제품 목록 쿼리에 대한 캐시 키를 생성합니다.
    고유성을 보장하기 위해 모든 매개변수를 포함합니다.
    """
    params = {
        "query_type": "product_list",
        "category_id": category_id,
        "order_by": "price_asc",
        "limit": limit,
        "offset": offset
    }
    # 복잡한 매개변수 세트에 대해 JSON 덤프와 MD5 해시 사용
    # 동일한 매개변수에 대해 결정론적 키 생성을 보장합니다.
    param_string = json.dumps(params, sort_keys=True) 
    hashed_key = hashlib.md5(param_string.encode('utf-8')).hexdigest()
    return f"product_query:{hashed_key}"

# 예시 사용법
category_id = 101
limit = 20
offset = 0
key = generate_product_cache_key(category_id, limit, offset)
print(f"생성된 캐시 키: {key}") 
# product_query:188c03c5b9f9a2e3f8b0d1e5c2a1f1b0 (예시 해시)

간단한 경우에는 문자열 연결로 충분할 수 있지만, 많은 매개변수 또는 복잡한 객체가 포함된 쿼리의 경우 매개변수를 직렬화(예: JSON으로)한 다음 해싱(예: MD5, SHA-256)하여 간결하고 결정론적인 키를 생성하는 것이 일반적이고 효과적인 접근 방식입니다. 삽입 순서에 관계없이 동일한 매개변수 세트가 동일한 키를 생성하도록 하려면 항상 직렬화된 객체 내의 키를 정렬하십시오(예: Python의 json.dumps에서 sort_keys=True).

캐시 무효화 전략

가장 완벽하게 설계된 캐시 키라도 데이터가 최신이 아니면 쓸모가 없습니다. 효과적인 캐시 무효화는 데이터 일관성을 유지하는 데 중요합니다. 몇 가지 일반적인 전략은 다음과 같습니다.

  1. 수명 (Time-To-Live, TTL):

    • 원칙: 각 캐시 항목에는 만료 시간이 주어집니다. 이 시간이 지나면 자동으로 제거되거나 최신이 아닌 것으로 표시됩니다.
    • 장점: 구현이 간단하고 관리가 쉬우며 최신이 아닌 데이터의 무기한 저장을 방지합니다.
    • 단점: TTL 기간 동안 데이터가 최신이 아닐 수 있습니다. 매우 일관성 있는 데이터 또는 자주 변경되는 데이터에는 이상적이지 않습니다. 최적의 TTL을 선택하는 것이 어려울 수 있습니다.
    • 적용: 약간의 최신이 아닌 상태가 허용되는 데이터(예: 뉴스 피드, 인기 있는 주제, 드물게 변경되는 참조 데이터)에 적합합니다.
    • 예시 (Redis SETEX 명령): 
      import redis

r = redis.Redis(host='localhost', port=6379, db=0)

user_id = 1
user_data = {"name": "Alice", "email": "alice@example.com"}
cache_key = f"user:profile:{user_id}"
ttl_seconds = 300 # 5분 동안 캐시

# TTL과 함께 사용자 데이터를 캐시에 저장
r.setex(cache_key, ttl_seconds, json.dumps(user_data)) 

# 나중에 사용자 데이터 검색
cached_data = r.get(cache_key)
if cached_data:
    print("캐시에서 로드됨")
    print(json.loads(cached_data))
else:
    print("캐시 미스, DB에서 로드하여 재캐시...")
    # DB에서 로드 로직
    # r.setex(cache_key, ttl_seconds, json.dumps(fresh_data))

  2. 쓰기 통과/쓰기 옆 무효화 (Write-Through / Write-Aside Invalidation):

    • 원칙: 기본 데이터베이스에 데이터가 쓰기나 업데이트될 때마다 해당 캐시 항목이 즉시 업데이트(쓰기 통과)되거나 명시적으로 삭제/무효화(쓰기 옆)됩니다.
    • 장점: 강력한 일관성을 보장하며, 캐시가 항상 최신 데이터베이스 상태를 반영합니다.
    • 단점: 쓰기 작업에 오버헤드가 추가됩니다. 무효화를 위해 관련 캐시 키를 모두 신중하게 식별해야 합니다.
    • 적용: 일관성이 가장 중요한 중요 데이터(예: 재무 거래, 재고 수준)에 이상적입니다. 이것은 종종 쓰기 시 무효화되는 '캐시 옆' 패턴으로 구현됩니다.

    예시 (쓰기 시 무효화되는 캐시 옆):

    import redis
import json

r = redis.Redis(host='localhost', port=6379, db=0)

def get_user_profile(user_id):
    cache_key = f"user:profile:{user_id}"
    cached_data = r.get(cache_key)
    if cached_data:
        print(f"사용자 {user_id}에 대한 캐시 히트")
        return json.loads(cached_data)
    
    print(f"사용자 {user_id}에 대한 캐시 미스, DB에서 로드...")
    # 데이터베이스에서 가져오는 것을 시뮬레이션
    user_data_from_db = {"id": user_id, "name": "Bob", "email": f"bob{user_id}@example.com"}
    
    # TTL과 함께 결과 캐시
    r.setex(cache_key, 300, json.dumps(user_data_from_db)) 
    return user_data_from_db

def update_user_profile(user_id, new_name):
    # 데이터베이스 업데이트 시뮬레이션
    print(f"DB에서 사용자 {user_id}를 이름: {new_name}으로 업데이트 중")
    # db.update("users", {"name": new_name}, where={"id": user_id})

    # 업데이트된 사용자에 대한 특정 캐시 키 무효화
    cache_key = f"user:profile:{user_id}"
    r.delete(cache_key)
    print(f"키에 대한 캐시 무효화: {cache_key}")

# -- 시나리오 ---
user_id = 2

# 첫 번째 로드 (캐시 미스)
profile1 = get_user_profile(user_id) 
print(profile1)

# 두 번째 로드 (캐시 히트)
profile2 = get_user_profile(user_id)
print(profile2)

# 사용자 프로필 업데이트
update_user_profile(user_id, "Robert")

# 세 번째 로드 (무효화로 인한 캐시 미스)
profile3 = get_user_profile(user_id)
print(profile3)

  3. 태그 기반 무효화 (또는 캐시 태그):

    • 원칙: 각 캐시 항목에 하나 이상의 '태그'를 할당합니다. 특정 태그와 관련된 데이터가 변경되면 해당 태그가 있는 모든 캐시 항목이 무효화됩니다.
    • 장점: 관련 항목 그룹의 무효화에 효율적입니다. 세분화된 키 관리를 추상화합니다.
    • 단점: 태그-키 매핑을 관리하기 위한 추가 계층이 필요합니다. 올바르게 구현하기 복잡할 수 있습니다.
    • 적용: 단일 데이터베이스 업데이트가 여러 캐시 쿼리에 영향을 미치는 경우 유용합니다(예: 제품 카테고리 업데이트는 해당 카테고리의 모든 제품 목록 쿼리 및 개별 제품 세부 정보 쿼리에 영향을 미칠 수 있음).

    구현 아이디어: Redis Set을 사용하여 태그를 관리할 수 있습니다. 예를 들어 제품 세부 정보와 제품 목록을 캐시하고 제품 가격이 변경되면 해당 제품과 관련된 모든 캐시를 무효화해야 합니다.

    // 태그 매핑 키 저장 (예: Redis Hash 또는 태그당 별도의 Redis 키)
// 캐시 키: product:123 -> 태그: product:123, category:electronics
// 캐시 키: product_list:category:electronics:page:1 -> 태그: category:electronics

// product 123이 업데이트될 때:
// 1. product 123과 관련된 모든 태그를 가져옵니다 (예: 'product:123', 'category:electronics').
// 2. 각 태그에 대해 관련된 모든 캐시 키를 검색합니다.
// 3. 검색된 모든 캐시 키를 삭제합니다.

// Redis SCAN을 사용하여 태그 패턴과 일치하는 키를 찾는 것과 같은 더 간단한 접근 방식
// 또는 고급 태그 지정을 위해 RediSearch와 같은 Redis 모듈 사용.
// 또는 더 일반적으로 Redis 세트에 태그당 명시적인 캐시 키 목록을 유지합니다.

    예시: Redis 세트에 범주별 모든 캐시 키를 저장합니다. category:101의 제품 변경 시: SINTERSTORE invalidation_keys category_tags_101 user_tags_123 (영향받는 엔티티의 가상 교차 연산) 그런 다음 DEL invalidation_keys

  4. 게시/구독 (Pub/Sub) 무효화:

    • 원칙: 데이터베이스 업데이트가 발생하면 Pub/Sub 채널에 이벤트가 게시됩니다. 구독자(다른 애플리케이션 인스턴스 또는 전용 캐시 무효화 서비스)는 이러한 이벤트를 수신 대기하고 로컬 캐시를 무효화하거나 Redis에 무효화 명령을 보냅니다.
    • 장점: 분리되어 있으며, 확장 가능하고, 분산 시스템에 강력합니다.
    • 단점: 이벤트 인프라의 복잡성이 추가됩니다. 무효화할 내용을 지정하기 위해 메시지 콘텐츠를 신중하게 설계해야 합니다.
    • 적용: 여러 서비스 또는 인스턴스가 데이터 변경에 반응해야 하는 대규모 분산 애플리케이션.

    예시 (의사 코드):

    # 데이터 업데이트 서비스에서:
def update_product_stock(product_id, new_stock):
    # DB 업데이트
    # db.update_product(product_id, new_stock)
    
    # 무효화 이벤트 게시
    r.publish("product_updates_channel", json.dumps({"product_id": product_id, "event_type": "stock_update"}))

# 캐시 서비스 또는 다른 애플리케이션 인스턴스에서:
def listen_for_invalidation_events():
    pubsub = r.pubsub()
    pubsub.subscribe("product_updates_channel")
    print("제품 업데이트 수신 대기 중...")
    for message in pubsub.listen():
        if message['type'] == 'message':
            event_data = json.loads(message['data'])
            product_id = event_data['product_id']
            
            # 특정 제품 캐시 키 무효화
            r.delete(f"product:detail:{product_id}")
            # 이 제품을 포함하는 제품 목록에 대한 다른 키를 파생해야 할 수 있습니다.
            # 예: 포함하는 제품 목록에 대한 키
            print(f"제품 {product_id} 관련 캐시 무효화됨")

# 별도의 스레드/프로세스에서 리스너 시작
# import threading
# threading.Thread(target=listen_for_invalidation_events).start()

올바른 전략 선택:

최적의 무효화 전략은 종종 이러한 접근 방식의 조합을 포함합니다. 예를 들어, 약간의 최신이 아닌 상태를 허용하는 일반 데이터에는 TTL을 사용하고, 즉각적인 일관성을 요구하는 중요 데이터에는 쓰기 통과/옆 무효화 또는 Pub/Sub 패턴을 사용합니다. 애플리케이션의 복잡성, 일관성 요구 사항 및 데이터 변경 빈도가 최상의 접근 방식을 결정합니다.

결론

Redis를 쿼리 결과 캐시로 활용하는 것은 애플리케이션 성능을 크게 향상시키고 데이터베이스 부하를 줄이는 강력한 기법입니다. 그러나 그 효과는 두 가지 중요한 측면에 달려 있습니다. 지능적인 캐시 키 디자인과 강력한 무효화 전략입니다. 쿼리를 정확하게 나타내는 고유하고 결정론적인 키를 구성하고 TTL, 명시적 삭제 또는 더 고급 태그 기반 또는 Pub/Sub 패턴과 같은 적절한 무효화 메커니즘을 구현함으로써 캐시가 빠르고 일관된 데이터의 원천이 되도록 보장할 수 있습니다. 신중하게 계획된 캐싱 전략은 선택 사항이 아니라 확장 가능하고 고성능 애플리케이션을 위한 기본 구성 요소입니다.

Share this article

HackerNews

More Posts from Leapcell

Popular Posts