Cache-Aside
개요
Cache-Aside는 캐시를 원본 저장소의 보조 수단으로 두고 애플리케이션이 둘을 직접 관리하는 캐싱 패턴이다. 먼저 캐시를 조회하고, 없으면 DB나 외부 API 같은 원본 저장소에서 읽은 뒤 캐시에 채운다.
Microsoft는 이를 "load data on demand into a cache from a data store"로 설명한다.1
다른 이름으로 Lazy Loading Cache라고도 부른다. AWS도 lazy caching 또는 cache-aside를 가장 흔한 캐싱 방식으로 설명한다.2
멋있게 쓰자면 다음처럼 요약된다.
Cache-Aside는 반복해서 읽는 값을 재사용해 원본 저장소의 부하를 줄인다. 애플리케이션은 갱신된 데이터의 캐시를 무효화하고, 오래된 값의 허용 시간과 캐시 미스가 몰릴 때의 부하, 캐시 장애 시 응답 경로를 함께 정한다.
핵심 구조
반복 조회가 매번 DB까지 내려가면 같은 데이터를 얻는 데도 저장소의 시간과 자원을 거듭 쓴다. Cache-Aside에서는 애플리케이션이 캐시 조회, 원본 조회, 캐시 채움과 무효화의 순서를 직접 제어한다.
역할 | 책임 |
|---|---|
애플리케이션 | 캐시를 먼저 보고, miss면 원본 저장소를 읽고, 결과를 캐시에 넣는다 |
캐시 | 자주 읽는 값을 빠르게 돌려준다 |
원본 저장소 | 최종 source of truth다 |
- 역할
애플리케이션
- 책임
캐시를 먼저 보고, miss면 원본 저장소를 읽고, 결과를 캐시에 넣는다
- 역할
캐시
- 책임
자주 읽는 값을 빠르게 돌려준다
- 역할
원본 저장소
- 책임
최종 source of truth다
상품 번호처럼 캐시의 값을 구별하는 이름을 키(key)라고 한다. 그 키의 값이 캐시에 있으면 hit, 없으면 miss이고, TTL은 그 값을 얼마 동안 캐시에 둘지 정하는 만료 시간이다. 이 용어들은 뒤의 예제와 판단 기준에서 계속 나온다. 기본 읽기 흐름은 이렇다.
요청이 들어온다.
애플리케이션이 캐시에서
key를 찾는다.cache hit이면 캐시 값을 반환한다.
cache miss이면 DB에서 읽는다.
읽은 값을 TTL과 함께 캐시에 저장한다.
값을 반환한다.
위 단계를 코드로 옮기면 이렇게 된다. 캐시 적중이면 DB 조회를 건너뛴다. 미적중이면 상품을 찾고, 상품이 있을 때만 캐시에 저장한다.
public async Task<ProductDto?> GetProductAsync(long productId, CancellationToken ct)
{
var cacheKey = $"product:{productId}:detail:v1";
var cached = await cache.GetAsync<ProductDto>(cacheKey, ct);
if (cached is not null)
{
// 가장 빠른 경로다. DB를 치지 않는다.
return cached;
}
// cache miss. 원본 저장소가 source of truth다.
var product = await productRepository.FindDtoAsync(productId, ct);
if (product is null)
{
return null;
}
// 너무 긴 TTL은 stale data를 늘리고, 너무 짧은 TTL은 DB 부하를 줄이지 못한다.
await cache.SetAsync(cacheKey, product, TimeSpan.FromMinutes(5), ct);
return product;
}
코드로 옮기면 역할이 둘로 갈린다. TypeScript 예제에서는 캐시를 읽고 쓰는 저장소로 Redis를, 원본 상품을 읽는 창구로 repository를 사용한다. Redis는 메모리에 값을 보관하는 저장소이고, repository는 여기서 상품 DB 조회를 맡는 코드다.
type ProductDto = {
id: number;
name: string;
price: number;
};
async function getProduct(productId: number): Promise<ProductDto | null> {
const cacheKey = `product:${productId}:detail:v1`;
const cached = await redis.get(cacheKey);
if (cached !== null) {
// JSON 역직렬화 실패가 나면 캐시 값이 깨졌다는 뜻이다.
// 실무에서는 로그를 남기고 캐시를 지운 뒤 DB fallback을 타게 만든다.
try {
return JSON.parse(cached) as ProductDto;
} catch {
await redis.del(cacheKey);
// 아래 DB fallback 경로로 내려간다.
}
}
// cache miss. DB가 source of truth다.
const product = await productRepository.findDto(productId);
if (product === null) {
return null;
}
// Redis EX는 초 단위 TTL이다.
// DTO 모양이 바뀌면 key 버전을 v2로 올린다.
await redis.set(cacheKey, JSON.stringify(product), { EX: 300 });
return product;
}
위 예제의 { EX: 300 }은 node-redis v4 문법이다. 클라이언트마다 TTL 지정 방식이 다르므로 아래 Redis로 구현할 때 절에서 따로
정리한다.
위 TS 예제의 JSON.parse try/catch도 설명용이다. 실제 코드에서는 cache serializer/adapter가 Corrupted, Miss, Down 같은 상태로 변환해 서비스 본문으로 넘긴다.
설명을 단순하게 하려고 앞의 예제는 null로 cache miss와 not found를 함께 표현한다. 운영 코드에서는 miss(캐시 없음), not found(엔티티 없음), cache down(캐시 장애)을 Result나 union으로 분리하는 편이 안전하다. Result는 성공과 실패를 값으로 돌려주는 타입을 가리킨다. 뒤의 에러 정책 절에서 이를 Hit / Miss / Down으로 나눈다.
언제 쓰는가?
Cache-Aside는 읽기 빈도가 높고, 약간 오래된 값을 허용할 수 있는 데이터에 잘 맞는다.
자주 쓰는 곳:
상품 상세
게시글 상세
카테고리 목록
설정값
권한 목록(짧은 TTL과 최종 검증 필요)
사용자 프로필 일부
대시보드 요약 데이터
외부 API 응답 중 짧게 재사용 가능한 값
판단 기준은 단순하다.
질문 | Cache-Aside 적합도 |
|---|---|
같은 key가 반복 조회되는가? | 높음 |
DB 조회나 외부 API 호출이 비싼가? | 높음 |
몇 초에서 몇 분 정도 stale data를 허용할 수 있는가? | 높음 |
쓰기보다 읽기가 훨씬 많은가? | 높음 |
항상 최신값이 필요한가? | 낮음 |
key별 무효화 기준이 모호한가? | 낮음 |
- 질문
같은 key가 반복 조회되는가?
- Cache-Aside 적합도
높음
- 질문
DB 조회나 외부 API 호출이 비싼가?
- Cache-Aside 적합도
높음
- 질문
몇 초에서 몇 분 정도 stale data를 허용할 수 있는가?
- Cache-Aside 적합도
높음
- 질문
쓰기보다 읽기가 훨씬 많은가?
- Cache-Aside 적합도
높음
- 질문
항상 최신값이 필요한가?
- Cache-Aside 적합도
낮음
- 질문
key별 무효화 기준이 모호한가?
- Cache-Aside 적합도
낮음
권한, 재고, 좌석, 결제 상태처럼 stale data의 비용이 큰 값은 조심해야 한다. Cache-Aside를 쓰더라도 TTL을 짧게 잡고, key에 tenant/user/role/scope/version 같은 경계를 넣고, 최종 판정은 DB나 권한 서버에서 다시 확인하는 경로가 필요하다. 경우에 따라 캐시하지 않는 편이 더 싸다.
왜 쓰는가?
원본 저장소 부하를 줄이고 응답 시간을 낮추기 위해 쓴다.
DB는 보통 정확성과 영속성을 담당한다. 캐시는 빠른 재사용을 담당한다. 캐시가 비어도 정답은 DB에서 다시 얻는다. 둘을 분리하면 다음 이점이 생긴다.
반복 조회가 DB까지 가지 않는다.
외부 API 호출 횟수를 줄인다.
피크 시간대 read traffic을 흡수한다.
자주 쓰는 데이터만 캐시에 올라오므로 메모리를 비교적 효율적으로 쓴다.
캐시를 잃어도 DB에서 다시 채울 수 있다.
AWS의 Redis 캐싱 전략 문서도 Cache-Aside의 장점으로 요청된 데이터만 캐시에 들어가 비용 효율적이고, 구현이 단순하며 즉각적인 성능 개선을 얻기 쉽다는 점을 든다.3
Redis로 구현할 때
이 문서의 예제는 캐시 저장소로 Redis를 쓴다. Redis는 인메모리 key-value 저장소로, 값은 기본적으로 문자열(바이트열)로 저장되며 list, hash, set, sorted set 같은 자료구조도 지원한다. Cache-Aside의 캐시 계층으로 가장 흔히 쓰인다.4
개인메모:물론 Redis말고도 다른 Valkey등도 있지만, 기본적으로 한국에서 의뢰인들이 알아먹을 수 있는 스택은 보통 Redis이므로, Redis 쓰는게 낫다.
명령이 원자적이다
Redis는 명령 실행을 단일 스레드 이벤트 루프 모델로 직렬화해 처리하므로, 개별 명령(GET, SET, DEL, INCR 등)은 원자적으로 보인다. Redis 6 이후 I/O threading이 있어도 명령 실행의 원자성 모델은 유지된다. 그래서 단일 연산에는 추가 락이 필요 없다.
다만 "GET으로 확인한 뒤 판단해서 SET" 같은 복합 동작은 여러 명령으로 쪼개지므로 원자적이지 않다는 것을 유의해야한다.
캐시 조회와 저장 사이에 DB 값이 바뀌면, 먼저 읽었던 낡은 값을 나중에 캐시에 써 넣을 수 있다. Redis를 써도 남는 이 순서 문제는 뒤의 쓰기 흐름에서 살펴본다.
명령 매핑
Cache-Aside의 각 단계는 Redis 명령으로 다음처럼 대응된다.
단계 | Redis 명령 |
|---|---|
캐시 조회 |
|
TTL과 함께 저장 |
|
무효화(삭제) |
|
없을 때만 저장 |
|
만료 확인·연장 |
|
배치 조회 |
|
- 단계
캐시 조회
- Redis 명령
GET key
- 단계
TTL과 함께 저장
- Redis 명령
SET key value EX seconds(또는SETEX key seconds value)
- 단계
무효화(삭제)
- Redis 명령
DEL key(큰 값은 비동기 삭제UNLINK key)
- 단계
없을 때만 저장
- Redis 명령
SET key value NX(단일 채움. 분산 락으로 쓰면 토큰+안전 해제 필요)
- 단계
만료 확인·연장
- Redis 명령
TTL key,EXPIRE key seconds
- 단계
배치 조회
- Redis 명령
MGET k1 k2 ...또는 파이프라이닝
클라이언트별 TTL 문법 차이
같은 SET ... EX라도 클라이언트마다 호출 형태가 다르다.
이 문서 예제는 node-redis v4 기준이다.
// node-redis v4
await redis.set(key, value, { EX: 300 });
await redis.set(key, value, { NX: true, PX: 3000 }); // 없을 때만, ms TTL
// ioredis
await redis.set(key, value, "EX", 300);
await redis.set(key, value, "PX", 3000, "NX");
// C# StackExchange.Redis
db.StringSet(key, value, TimeSpan.FromMinutes(5));
db.StringSet(key, value, TimeSpan.FromSeconds(3), when: When.NotExists); // NX
직렬화와 key 버전
값이 문자열이므로 객체는 JSON 등으로 직렬화해 저장하고, 읽을 때 역직렬화한다. 그래서 DTO 모양이 바뀌면 역직렬화가 깨질 수 있고, 뒤의 Key 설계 절처럼 key에 v1, v2 버전을 넣어 옛 캐시와 새 캐시를 분리한다. 값의 모양이 바뀌는 순간이 key를 바꿔야 하는 순간이다.
메모리 한계와 eviction
Redis는 maxmemory와 eviction 정책으로 캐시 용량을 관리한다. 5 TTL은 시간에 따른 만료를, eviction은 메모리 압박에 따른 제거를 정하므로 TTL이 남은 키도 제거될 수 있다. noeviction 정책에서는 메모리를 더 요구하는 쓰기가 오류로 거절된다. 애플리케이션은 이런 캐시 저장 실패와 캐시 미스를 구별하고, 캐시 장애 처리 절의 정책을 적용한다.
메모리 파편화
캐시를 오래 돌리면 메모리 쪽에서 다른 문제가 드러난다. DEL 후 재조회 시 SET하는 방식은 레이스를 줄이는 안전한 선택이지만, 크기가 제각각인 값(JSON, MessagePack 등)이 끊임없이 지워지고 다시 쓰이면 Redis의 메모리 할당자(jemalloc) 안에 빈 공간이 흩어지는 파편화가 쌓인다. 그러면 논리적 데이터 크기는 작아도 물리 메모리(RSS)가 부풀어, OS의 OOM 킬러가 Redis를 죽일 수 있다.
운영에서는 mem_fragmentation_ratio와 함께 RSS 차이의 절대 크기인 mem_fragmentation_bytes, 할당자 자체의 파편화 지표인 allocator_frag_ratio와 allocator_frag_bytes를 본다. 작은 데이터셋에서는 고정 오버헤드만으로 비율이 1.5를 넘을 수 있으니, 실제 메모리 여유와 할당자 지표를 확인한 뒤 activedefrag 적용을 판단한다.6 Redis INFO의 메모리 지표 정의
개인메모:내 경험은 아니고 커뮤니티에서 질문을 검색하면 나오는 것들이다. 그러니까 선배 프로그래머의 경험이라고 할 수 있겠지.
영속성에 기대지 않는다
Redis는 RDB 스냅샷이나 AOF로 디스크에 남길 수 있지만, Cache-Aside의 캐시 용도라면 이 영속성에 의존하지 않는다.
진실의 원천(source of truth)는 어디까지나 DB이고, 캐시는 비어도 복구 가능한 보조 계층으로 다룬다.
분산 환경 주의
여러 앱 서버가 같은 Redis를 공유하므로, 뒤의 Cache Stampede 절에서 다룰 한 프로세스 안에서만 공유하는 락(C#의 SemaphoreSlim, Node의 in-flight Map)만으로는 서버 전체 기준 stampede를 막지 못한다. 이때 SET key value NX PX ttl 기반의 단순 분산 락이나 Redlock류, 같은 조회 요청을 하나로 모으는 request coalescing 계층을 함께 본다.
분산 락으로 쓸 때는 value에 매번 다른 random token을 넣고, 해제할 때도 Lua로
"GET 값이 내 token과 같을 때만 DEL"해야 한다. 단순 DEL은 내 락이 만료된 뒤 다른 요청이 새로 잡은 락을 지워버릴 수 있다.78
그리고 분산 락 자체가 만료 타이밍과 네트워크 분단에서 정확성 보장이 까다로우므로, 보호 대상이 정합성인지 단순 부하 완화인지 먼저 구분하고 적용한다.
Write 흐름
앞까지의 읽기 흐름은 단순했다. Cache-Aside에서 어려운 쪽은 읽기가 아니라 쓰기다. 원본 저장소와 캐시가 동시에 존재하므로, 쓰기 후 캐시를 어떻게 처리할지 정해야 한다.
경험적으로 대부분의 책에서 말하는 방식은
DB를 먼저 갱신하고 캐시를 삭제하는 것이다.
캐시를 먼저 지우면 DB 갱신 전의 읽기가 이전 값을 다시 채울 수 있으므로, 원본 갱신을 커밋한 뒤 해당 캐시를 지운다. 커밋된 값을 볼 수 있는 원본 조회라면 그 뒤의 미스는 새 값을 가져오고, 삭제 전의 캐시 적중은 기존 값을 돌려줄 수 있다. 다음 예제는 이 순서에서도 먼저 읽어 둔 값이 늦게 도착하는 경우를 보여 준다.
public async Task UpdateProductNameAsync(long productId, string name, CancellationToken ct)
{
var cacheKey = $"product:{productId}:detail:v1";
// source of truth를 먼저 바꾼다.
await productRepository.UpdateNameAsync(productId, name, ct);
// 캐시는 다음 읽기에서 다시 채우게 한다.
// update보다 delete가 단순한 경우가 많다.
await cache.RemoveAsync(cacheKey, ct);
}
TypeScript 예:
async function updateProductName(productId: number, name: string): Promise<void> {
const cacheKey = `product:${productId}:detail:v1`;
// 먼저 원본 저장소를 바꾼다.
await productRepository.updateName(productId, name);
// Cache-Aside에서는 보통 값을 다시 쓰기보다 삭제한다.
// 다음 read가 DB에서 새 값을 읽고 캐시를 다시 채운다.
await redis.del(cacheKey);
}
캐시를 삭제하면 다음 읽기가 원본 조회로 값을 다시 구성한다. 이 방식을 쓸 때도 동시에 진행 중인 읽기가 어떤 값을 나중에 저장하는지 살펴야 한다.
방식 | 장점 | 위험 |
|---|---|---|
DB 갱신 후 캐시 삭제 | 가장 흔하고 상대적으로 안전하다 | 다음 요청은 cache miss가 난다. 동시 read/write에서는 stale value가 다시 캐시에 들어갈 수 있다 |
DB 갱신 후 캐시 갱신 | 다음 읽기가 빠르다 | 캐시 값 구성 로직이 DB 조회 로직과 중복될 수 있다 |
캐시 갱신 후 DB 갱신 | 거의 피한다 | DB 실패 시 캐시가 거짓말을 한다 |
- 방식
DB 갱신 후 캐시 삭제
- 장점
가장 흔하고 상대적으로 안전하다
- 위험
다음 요청은 cache miss가 난다. 동시 read/write에서는 stale value가 다시 캐시에 들어갈 수 있다
- 방식
DB 갱신 후 캐시 갱신
- 장점
다음 읽기가 빠르다
- 위험
캐시 값 구성 로직이 DB 조회 로직과 중복될 수 있다
- 방식
캐시 갱신 후 DB 갱신
- 장점
거의 피한다
- 위험
DB 실패 시 캐시가 거짓말을 한다
대표 race:
요청 A가 cache miss를 본다.
A가 DB에서 old value를 읽는다.
요청 B가 DB를 new value로 갱신한다.
B가 cache delete를 수행한다.
A가 조금 늦게 old value를 cache set한다.
이후 캐시에 old value가 살아남는다.
이 순서에서는 A가 이전 값을 읽어 둔 뒤 B의 캐시 삭제보다 늦게 저장하면서 낡은 값이 되살아난다. 원본 읽기에 쓰는 복제본과 트랜잭션 snapshot도 확인해야 한다. 지연된 복제본이나 이전 Repeatable Read snapshot에서는 B가 커밋한 뒤에 시작한 조회도 이전 값을 가져올 수 있다. PostgreSQL의 격리 수준 설명
이 문제를 stale value resurrection이라고 부를 수 있다.
이름이 거창하지만 현상은 단순하다.
이미 지운 낡은 값이 다시 살아나는 것이다.
개인메모: 영화에서도 그렇고 확인 사살이 중요하다.
Lua 스크립트로 stale 부활 막기
stale-set 레이스를 더 단단히 막으려면,
캐시에 쓸 때 "내가 읽은 버전이 아직 최신일 때만 쓴다"는 조건을 원자적으로 검사해야 한다. 그런데 위 레이스에서는 B가 이미 키를 지웠으므로 SET NX(없을 때만 쓰기)는 그냥 통과해 버린다.
없음과 "낡았음"을 구분하지 못하기 때문이다.
대신 키마다 논리적 버전(또는 타임스탬프)을 두고, Redis Lua 스크립트로 "내가 읽은 버전이 아직 최신일 때만 쓴다"를 원자적으로 검사한다.
Lua는 Redis에서 원자적으로 돌기 때문에 GET과 SET 사이에 끼어드는 명령이 없다.9
여기서 보통 자주 실수하는 것으로 버전을 Cache value key 안에 저장하는 것으로 모든 것이 해결될 것이라 생각하는 것이다.
버전을 cache value key 안에 함께 저장하는 것만으로는 부활을 막지 못한다.
update 시 그 키를 삭제하면 버전도 같이 사라지기 때문이다. 늦게 도착한 old writer는 버전이 없는(nil) 상태를 보고 그대로 써버린다.
A가 DB에서 version 1을 읽음
B가 DB를 version 2로 갱신
B가 cache key를 DEL (안에 있던 ver도 함께 사라짐)
A가 늦게 Lua 실행 -> HGET ver = nil -> 통과 -> old value 부활
무효화로 지우는 것만으로는 늦게 도착한 쓰기를 막을 수 없다. 그래서 old writer를 막으려면 캐시 무효화로 지워지지 않는 별도의 version fence key(또는 tombstone marker)가 필요하다. fence는 그 키의 최신 버전을 들고 있다.
-- KEYS[1] = cache value key, KEYS[2] = version fence key
-- ARGV[1] = value, ARGV[2] = my_version, ARGV[3] = ttl_seconds
-- 버전은 0..2^53-1의 정수이며 엔티티별로 엄격히 증가한다.
local fence = redis.call('GET', KEYS[2])
if not fence or tonumber(ARGV[2]) ~= tonumber(fence) then
return 0 -- fence가 없거나 현재 버전과 다르면 캐시 채움을 건너뛴다.
end
redis.call('SET', KEYS[1], ARGV[1], 'EX', ARGV[3])
return 1
스크립트는 기존 읽기 코드와 같은 문자열 값을 SET으로 저장하고 TTL도 함께 지정한다. 버전은 별도 fence key에서 검사하므로 값의 저장 형식을 hash로 바꾸지 않는다. 쓰기(write) 흐름은 이렇게 맞춘다.
DB commit
-> 하나의 Redis Lua에서 fence를 현재 값과 new_version 중 큰 값으로 갱신
-> 같은 Lua 안에서 cache value key를 DEL
fence가 없으면 값을 삭제하고 재초기화 대상으로 남긴다.
여기서 writer는 큰 버전만 남기는 비교·갱신과 캐시 삭제를 하나의 Lua 실행으로 묶는다. 일반 SET으로 덮어쓰면 v3을 반영한 뒤 늦게 도착한 v2 writer가 fence를 2로 되돌릴 수 있다. 버전은 해당 엔티티의 DB 갱신과 함께 엄격히 증가하는 0..2^53−1 정수로 정하고, reader는 fence와 버전이 같을 때만 채운다. fence가 없으면 DB 조회 결과만 반환하고 캐시 채움을 건너뛴다. 이 예제는 캐시 값에 TTL을 두고 fence에는 두지 않으며, volatile 계열 eviction 정책으로 fence를 제거 대상에서 제외한다. Redis 상태를 잃어 재초기화할 때는 쓰기를 잠시 멈춘 구간에서 캐시 값을 비우고 DB의 현재 버전으로 fence를 재구축한 뒤 채움을 재개한다.
Redis Cluster 주의: CROSSSLOT와 hash tag
위 Lua는 KEYS[1](캐시 값)과 KEYS[2](fence) 두 키를 함께 만진다. 단일 노드에서는 문제없지만, 샤딩된 Redis Cluster에서는 두 키가 서로 다른 해시 슬롯에 배치될 수 있다. 그러면 멀티키 명령·스크립트가 원자성을 보장할 수 없어 CROSSSLOT 에러로 즉시 실패한다.1011
해결책은 두 키를 같은 슬롯에 강제로 묶는 hash tag다. 키 이름에 중괄호 {}를 넣으면 Redis는 중괄호 안 문자열만 해싱에 사용한다. 같은 태그를 공유하는 키는 항상 같은 슬롯에 들어간다.
나쁜 예 : product:123:val / product:123:fence (다른 슬롯에 갈 수 있음)
좋은 예 : {product:123}:val / {product:123}:fence (같은 슬롯 보장)
즉 클러스터에서 멀티키 Lua를 쓰려면, 함께 다루는 키들이 동일한 hash tag를 공유하도록 key 네이밍 규칙을 표준화해야 한다. Key 설계 규칙에 hash tag(예: {product:123}:detail:v1)를 포함시켜 두는 편이 깔끔하다. 앞의 Key 설계 예시에 있는 중괄호는 코드의 문자열 보간이라 hash tag가 아니다.
DB 커밋과 캐시 무효화 사이의 실패 처리
DB 커밋 뒤 Redis 반영까지는 별도 단계로 진행된다. 커밋이 성공해도 fence 갱신이나 캐시 삭제가 실패할 수 있으므로, 실패한 무효화를 outbox나 작업 기록에 남기고 worker가 재처리하게 한다. DB 커밋 이후 Redis에 반영될 때까지의 지연과 재처리 상태를 관측해야 복구가 끝났는지 판단할 수 있다.
현장판단 기준:
DB commit이 끝난 뒤 캐시를 지운다.
캐시 삭제 실패는 로그와 재시도 대상으로 본다.
캐시 값이 여러 key로 퍼져 있으면 무효화 목록을 명확히 둔다.
캐시가 source of truth가 되지 않게 한다.
TTL 설계
TTL(Time To Live)은 캐시 값이 살아 있는 시간이다. Cache-Aside에서 TTL은 성능과 일관성 사이의 조절 장치다. 그래서 TTL은 데이터 묶음마다 따로 정한다.
TTL | 결과 |
|---|---|
너무 짧음 | cache miss가 많아져 DB 부하가 줄지 않는다 |
너무 김 | 오래된 값이 오래 보인다 |
없음 | 무효화 누락 시 데이터가 계속 썩는다 |
- TTL
너무 짧음
- 결과
cache miss가 많아져 DB 부하가 줄지 않는다
- TTL
너무 김
- 결과
오래된 값이 오래 보인다
- TTL
없음
- 결과
무효화 누락 시 데이터가 계속 썩는다
아래 시간은 튜닝을 시작할 때 넣어 보는 예시다. 실제 TTL은 허용할 갱신 지연과 조회 빈도, 무효화 경로를 함께 보고 정한다.
데이터 | TTL 예시 |
|---|---|
상품 상세 | 1분에서 10분 |
카테고리 목록 | 10분에서 1시간 |
권한 목록 | 수십 초에서 수분 |
대시보드 요약 | 10초에서 5분 |
환율, 재고, 좌석 | 도메인에 따라 매우 짧게 |
- 데이터
상품 상세
- TTL 예시
1분에서 10분
- 데이터
카테고리 목록
- TTL 예시
10분에서 1시간
- 데이터
권한 목록
- TTL 예시
수십 초에서 수분
- 데이터
대시보드 요약
- TTL 예시
10초에서 5분
- 데이터
환율, 재고, 좌석
- TTL 예시
도메인에 따라 매우 짧게
같은 상품 가격도 목록에서 보여 줄 때와 결제를 확정할 때의 최신성 요구가 다르다. 어떤 화면과 판단에 쓰는 값인지 먼저 정하고, 오래된 값의 허용 시간을 TTL과 무효화 정책에 반영한다.
개인메모: 사실 이 대략적 감각은 Redis 강의 파는 사람들 강의에서 예시로 만들어 둔 것을 가져온 것이다.
Key 설계
캐시 key는 나중에 운영자가 보고도 의미를 알 수 있어야 한다.
좋은 key 예:
var key = $"product:{productId}:detail:v1";
TypeScript에서는 key builder 함수로 모아두는 편이 낫다.
function productDetailKey(productId: number): string {
return `product:${productId}:detail:v1`;
}
key에 넣을 것:
도메인 이름:
product,user,permission식별자:
123조회 모양:
detail,summary,permissions버전:
v1,v2
버전은 중요하다. DTO 모양이 바뀌었는데 기존 캐시 값을 그대로 읽으면 역직렬화 오류나 이상한 응답이 날 수 있다. 이때 key 버전을 올리면 오래된 캐시와 새 캐시를 자연스럽게 분리할 수 있다.
나쁜 key 예:
var key = id.ToString();
TypeScript에서도 마찬가지다.
const key = String(id);
이런 key는 다른 도메인과 충돌하기 쉽고, 운영 중에 어떤 값인지 알아보기 어렵다.
Cache Stampede
Cache Stampede는 인기 key가 동시에 만료되면서 많은 요청이 한꺼번에 DB로 몰리는 현상이다.
상황:
product:1캐시가 만료된다.동시에 요청 1,000개가 들어온다.
모두 cache miss를 본다.
모두 DB를 조회한다.
DB가 캐시 대신 트래픽을 그대로 맞는다.
대응 방법:
TTL에 작은 임의의 시간차(jitter)를 섞어 동시에 만료되지 않게 한다.
같은 key에 대해 한 요청만 DB를 조회하게 한다.
오래된 값을 잠깐 반환하고 갱신은 뒤에서 진행하는 stale-while-revalidate 방식을 쓴다.
인기 key는 요청이 몰리기 전에 미리 채운다(warming).
아래 C# 예제는 같은 키의 캐시 채움을 직렬화한다. 앞선 조회가 성공해 캐시를 채우면 대기 중인 요청은 그 값을 쓰고, not-found나 실패 결과는 뒤의 Lazy<Task> 예제처럼 진행 중인 작업을 공유하는 방식으로 합친다.
private static readonly ConcurrentDictionary<string, SemaphoreSlim> Locks = new();
public async Task<ProductDto?> GetProductAsync(long productId, CancellationToken ct)
{
var key = $"product:{productId}:detail:v1";
var cached = await cache.GetAsync<ProductDto>(key, ct);
if (cached is not null)
{
return cached;
}
var gate = Locks.GetOrAdd(key, _ => new SemaphoreSlim(1, 1));
await gate.WaitAsync(ct);
try
{
// lock을 잡기 전에 다른 요청이 이미 캐시를 채웠을 수 있으므로 다시 확인한다.
cached = await cache.GetAsync<ProductDto>(key, ct);
if (cached is not null)
{
return cached;
}
var product = await productRepository.FindDtoAsync(productId, ct);
if (product is null)
{
return null;
}
await cache.SetAsync(key, product, TimeSpan.FromMinutes(5), ct);
return product;
}
finally
{
gate.Release();
}
}
이 C# 예제도 단일 애플리케이션 프로세스 안에서만 중복 조회를 줄인다. 서버가 여러 대면 각 서버가 자기 프로세스 안에서만 lock을 잡기 때문에 Redis 전체 기준 stampede는 막지 못한다. 그 경우 Redis lock, distributed lock, request coalescing 계층, background refresh 같은 별도 전략이 필요하다.
또한 위 예제는 단순화를 위해 Locks 정리 로직을 생략했다. key 종류가 많은 서비스에서 ConcurrentDictionary<string, SemaphoreSlim>을 계속 키우면 lock 객체가 남을 수 있다. 실제 서비스에서는 ref-count, 만료형 lock map, Lazy<Task> 기반 coalescing 같은 정리 전략을 둔다. 대충 CurrentCount만 보고 TryRemove를 넣으면, 기다리는 요청과 새 요청이 서로 다른 lock을 잡는 더 나쁜 race를 만들 수 있다.
TypeScript에서 단일 Node.js 프로세스 안의 중복 조회를 줄이는 간단한 형태는 Map에 진행 중인 Promise를 저장하는 방식이다.
const inFlight = new Map<string, Promise<ProductDto | null>>();
async function getProductWithSingleFlight(productId: number): Promise<ProductDto | null> {
const key = productDetailKey(productId);
const cached = await redis.get(key);
if (cached !== null) {
return JSON.parse(cached) as ProductDto;
}
const existing = inFlight.get(key);
if (existing !== undefined) {
// 같은 key를 이미 다른 요청이 DB에서 읽고 있다.
// 새 DB 쿼리를 만들지 않고 같은 Promise를 기다린다.
return existing;
}
const loading = (async () => {
try {
// 기다리는 동안 다른 요청이 캐시를 채웠을 수 있으므로 다시 확인한다.
const secondCached = await redis.get(key);
if (secondCached !== null) {
return JSON.parse(secondCached) as ProductDto;
}
const product = await productRepository.findDto(productId);
if (product === null) {
return null;
}
await redis.set(key, JSON.stringify(product), { EX: 300 });
return product;
} finally {
inFlight.delete(key);
}
})();
inFlight.set(key, loading);
return loading;
}
이 예제는 단일 프로세스 안에서만 통한다. 서버가 여러 대면 Redis lock, request coalescing, background refresh 같은 별도 전략이 필요하다.
분산 환경: 확률적 조기 만료 (PER / XFetch)
분산 환경에서 락 조율 비용이 문제가 되는 hot key에는 확률적 조기 재계산(PER, Probabilistic Early Recomputation), 흔히 XFetch라 부르는 기법도 쓸 수 있다. 각 요청이 만료 전에 갱신할 확률을 계산해 재계산 시점을 분산한다.12
스탬피드 방어 전략을 한눈에 비교하면 이렇다.
전략 | 보장 | 비용 |
|---|---|---|
Single-flight | 프로세스 내부 중복 조회 감소 | 서버 여러 대면 한계 |
Distributed lock | key 단위 재계산 수를 강하게 제한 | 락 비용, 만료·분단 이슈 |
PER / XFetch | 확률적으로 stampede 완화 | 정확히 1개만 재계산 보장 안 함 |
Stale-while-revalidate | 사용자 지연 최소화 | 백그라운드 작업 생명주기 필요 |
- 전략
Single-flight
- 보장
프로세스 내부 중복 조회 감소
- 비용
서버 여러 대면 한계
- 전략
Distributed lock
- 보장
key 단위 재계산 수를 강하게 제한
- 비용
락 비용, 만료·분단 이슈
- 전략
PER / XFetch
- 보장
확률적으로 stampede 완화
- 비용
정확히 1개만 재계산 보장 안 함
- 전략
Stale-while-revalidate
- 보장
사용자 지연 최소화
- 비용
백그라운드 작업 생명주기 필요
핵심은, 캐시가 실제로 만료되기 전에 각 요청이 일정 확률로 "내가 미리
갱신하겠다"고 독립적으로 판정하는 것이다.
만료가 가까울수록 그 확률이 지수적으로 커진다. 판정식은 다음과 같다.
now - delta * beta * ln(rand()) >= expiry
now : 현재 시각
delta : 값을 재계산(DB 조회)하는 데 걸린 시간
beta : 확률 가중치 (보통 1, 키울수록 더 일찍 갱신)
rand() : 0과 1 사이 난수
expiry : 캐시의 논리적 만료 시각
ln(rand())이 음수이므로 좌변은 now보다 큰 값이 되고, now가 expiry에 가까워질수록 조건이 참이 될 확률이 커진다. 만료 전에 당첨된 요청이 미리 DB를 조회해 캐시를 갱신하고, 나머지 요청은 아직 살아 있는 기존 값을 그대로 받는다. 여러 요청이 동시에 당첨되면 재계산도 겹친다.
운이 나쁘거나 트래픽이 크면 여러 요청이 동시에 재계산할 수 있다. 다만 분산 락 없이 재계산 요청 수를 확률적으로 줄여, 만료 시점에 모든 요청이 한꺼번에 DB로 몰리는 현상을 크게 완화한다.
구현하려면 값과 함께 delta(재계산 비용)와 논리적 만료 시각을 저장하고, Redis의 실제 TTL은 그 만료보다 약간 길게 둬서 조기 갱신 여유를 남긴다.
type Wrapped<T> = { value: T; deltaMs: number; expiresAt: number };
function shouldEarlyRecompute(deltaMs: number, expiresAt: number, beta = 1): boolean {
// Math.random()이 0이면 Math.log(0) = -Infinity가 되므로 EPSILON으로 막는다.
const random = Math.max(Number.EPSILON, Math.random());
// ln(random)은 음수이므로 (now - delta*beta*ln(random))은 now보다 커진다.
const gap = deltaMs * beta * Math.log(random);
return Date.now() - gap >= expiresAt;
}
async function getProductXFetch(productId: number): Promise<ProductDto | null> {
const key = `${productDetailKey(productId)}:xfetch:v1`;
const raw = await redis.get(key);
if (raw !== null) {
const wrapped = JSON.parse(raw) as Wrapped<ProductDto>;
if (!shouldEarlyRecompute(wrapped.deltaMs, wrapped.expiresAt)) {
return wrapped.value; // 대부분의 요청이 여기서 끝난다.
}
// 당첨된 요청만 아래로 내려가 미리 갱신한다. 기존 값은 아직 유효하다.
}
const start = Date.now();
const product = await productRepository.findDto(productId);
if (product === null) {
return null;
}
const deltaMs = Date.now() - start;
const ttlSeconds = 300;
const wrapped: Wrapped<ProductDto> = {
value: product,
deltaMs,
expiresAt: Date.now() + ttlSeconds * 1000,
};
// 실제 TTL은 논리 만료보다 약간 길게 둔다.
await redis.set(key, JSON.stringify(wrapped), { EX: ttlSeconds + 10 });
return product;
}
이 예제에서는 당첨된 요청이 DB 조회를 await한 뒤 새 값을 돌려주는 lock-free early refresh를 구현한다. stale-while-revalidate로 동작시키려면 기존 값을 먼저 반환하고 갱신 작업을 수명과 실패 처리가 정해진 백그라운드 실행기로 넘긴다.
ASP.NET Core에서 _ = Task.Run(...)으로 분리한 작업은 요청의 서비스 수명과 예외 관측을 별도로 관리해야 한다. 요청이 끝난 뒤 해제된 서비스를 사용하거나 배포·재시작 중 작업을 잃는 일을 피하려면 BackgroundService나 IHostedService가 Channel<T>의 작업을 소비하게 한다. 프로세스 종료 뒤에도 갱신을 반드시 재개해야 하는 요구는 별도 영속 큐로 처리한다.13
C#도 판정 구조는 같아서, 값과 함께 deltaMs, expiresAt을 저장하고 위 판정식을 적용하면 된다. PER은 분산 락이 부담스러운 읽기 위주 hot key에 특히 잘 맞는다.
인프로세스 코얼레싱의 메모리: Lazy 패턴
앞의 ConcurrentDictionary<string, SemaphoreSlim>은 동기화 객체를 직접 들고 있어 정리 전략이 필요했고, 어설픈 TryRemove는 더 나쁜 race를 만든다. 대안은 lock이 아니라 진행 중인 작업 자체를 값으로 들고, 작업이 끝나면 스스로 빠지게 하는 것이다.
ConcurrentDictionary<string, Lazy<Task<Result<ProductDto>>>>를 쓰면, GetOrAdd로 같은 key의 동시 요청이 단 하나의 Lazy를 공유한다. Lazy는 Task를 한 번만 시작하므로 DB 조회도 한 번만 일어나고, 기다리는 모든 요청은 같은 Task를 await해 같은 Result를 받는다. 그리고 그 Task의 완료 시점(continuation)에 해당 key를 맵에서 제거하면, 맵은 "전체 key 수"가 아니라 "현재 진행 중인 key 수"만큼만 커진다. 즉 자기정리되므로 별도 eviction 스레드도, semaphore 정리도 필요 없다.
요점은 동기화 프리미티브(SemaphoreSlim)를 공유하는 대신, 진행 중인 동일한 Task 핸들을 공유한다는 것이다. 메모리는 동시성 수준에 비례해 묶이고, 완료 즉시 제거로 GC 부담도 최소화된다. (continuation에서 제거할 때, 추가가 제거보다 늦어 새 Lazy가 끼는 경계만 주의하면 된다.)
아래 코드는 설명을 단순화하기 위해 Result<T> 대신 ProductDto?를 쓴다. 실제 코드에서는 miss와 failure를 구분하려고 Result<T>나 전용 union을 쓴다.
private readonly ConcurrentDictionary<string, Lazy<Task<ProductDto?>>> inFlight = new();
public Task<ProductDto?> CoalesceAsync(string key, Func<Task<ProductDto?>> factory)
{
var lazy = inFlight.GetOrAdd(
key,
_ => new Lazy<Task<ProductDto?>>(
factory,
LazyThreadSafetyMode.ExecutionAndPublication));
return AwaitAndRemoveAsync(key, lazy);
}
private async Task<ProductDto?> AwaitAndRemoveAsync(
string key,
Lazy<Task<ProductDto?>> lazy)
{
try
{
return await lazy.Value.ConfigureAwait(false);
}
finally
{
// key와 lazy가 모두 일치할 때만 제거해, 그 사이 끼어든 새 Lazy를 지우는 race를 피한다.
inFlight.TryRemove(new KeyValuePair<string, Lazy<Task<ProductDto?>>>(key, lazy));
}
}
GetOrAdd의 factory가 Lazy를 만들고 Lazy.Value가 Task를 단 한 번 시작한다. TryRemove에 key와 lazy를 함께 넘기는 것이 핵심이다. 그래야 그 사이 다른 요청이 새로 넣은 Lazy를 실수로 지우지 않는다.
Negative Caching
없는 값도 반복 조회될 수 있다. 예를 들어 존재하지 않는 상품 ID나 삭제된 사용자 ID를 계속 조회하면 매번 DB를 치게 된다.
이때 짧은 TTL로 "없음"을 캐싱할 수 있다.
var missingKey = $"product:{productId}:missing:v1";
var isMissing = await cache.GetAsync<bool?>(missingKey, ct);
if (isMissing is true)
{
return null;
}
var product = await productRepository.FindDtoAsync(productId, ct);
if (product is null)
{
// 없는 값은 짧게만 캐싱한다.
// 나중에 같은 ID가 생성될 가능성이 있거나 복구될 수 있기 때문이다.
await cache.SetAsync(missingKey, true, TimeSpan.FromSeconds(30), ct);
return null;
}
TypeScript 예:
async function getProductWithNegativeCache(productId: number): Promise<ProductDto | null> {
const missingKey = `product:${productId}:missing:v1`;
const missing = await redis.get(missingKey);
if (missing !== null) {
return null;
}
const product = await productRepository.findDto(productId);
if (product === null) {
// 없는 값은 짧게만 캐싱한다.
await redis.set(missingKey, "1", { EX: 30 });
return null;
}
return product;
}
주의할 점:
negative cache TTL은 짧게 둔다.
negative cache를 별도 key로 둘 경우, 해당 엔티티가 생성되거나 복구될 때 missing key도 함께 삭제한다.
권한, 결제, 재고처럼 상태 변화가 민감한 값에는 조심한다.
"없음"과 "캐시 장애"를 구분해야 한다.
캐시 장애 처리
캐시가 멈추면 반복 읽기를 DB가 직접 받게 된다. 원본 저장소가 감당할 수 있는 유입량을 정하고, 그 한도를 넘는 요청에는 빠른 실패나 업무상 허용한 축소 응답을 돌려주도록 설계한다.
읽기에서 캐시가 죽었을 때:
아래 예제는 캐시 읽기의 실패를 잡아 DB 조회로 이어지는 흐름을 보여 준다. 요청 취소는 그대로 전파하고, 캐시 인프라 실패의 변환은 어댑터에 모은다. 뒤의 에러 정책 절에서 이 결과를 값으로 구분한다.
try
{
var cached = await cache.GetAsync<ProductDto>(key, ct);
if (cached is not null)
{
return cached;
}
}
catch (OperationCanceledException) when (ct.IsCancellationRequested)
{
throw;
}
catch (Exception ex)
{
// 캐시 장애는 기록하되, 가능하면 DB로 fallback한다.
logger.LogWarning(ex, "Cache read failed. key={CacheKey}", key);
}
return await productRepository.FindDtoAsync(productId, ct);
현장 판단 기준:
캐시 read 실패는 가능하면 DB fallback한다.
캐시 write 실패는 응답 실패로 만들지 않는 경우가 많다.
캐시 timeout은 짧게 둔다.
캐시 장애 시 무조건 DB fallback하면 DB까지 연쇄 장애가 날 수 있다. timeout, circuit breaker, rate limit, degraded response, stale cache 반환 같은 보호 전략도 같이 본다.
캐시 장애율, hit ratio, miss ratio를 모니터링한다.
캐시가 죽었을 때 DB가 버틸 수 있는지도 따져야 한다.
마지막 항목이 중요하다. 캐시가 죽으면 모든 읽기가 DB로 돌아간다. 평소에 캐시 hit ratio가 95%였던 서비스는 캐시 장애 순간 DB 트래픽이 20배 가까이 늘 수 있다.
캐시 호출을 보호하는 Circuit Breaker는 캐시 연산의 실패를 직접 관측하고, DB 호출의 실패는 DB용 회로에서 따로 집계한다. 전체 조회 바깥에 회로 하나만 두면 캐시 실패 뒤 DB가 성공한 요청을 성공으로 셀 수 있다. DB fallback에 들어가는 요청은 bulkhead나 동시성·요청량 제한으로 별도 통제하고, 한도 초과 시 응답 정책도 정해 둔다.14
에러 정책: Result 타입과 가드 클로즈
위 예제들은 cache miss를 null로, 캐시 장애를 try/catch로 다룬다. 빠른 설명에는 충분하지만, 정합성과 아키텍처 경계가 중요한 서비스에서는 두 가지가 걸린다. 첫째, miss(값이 없음)와 failure(캐시가 죽음)가 둘 다 null로 뭉개져 호출자가 구분할 수 없다. 둘째, try/catch가 조회 비즈니스 로직 안으로 침투해 제어 흐름이 된다.
이 예제에서는 캐시 조회 결과를 Hit / Miss / Down 값으로 나누고, 인프라 예외를 변환하는 try/catch를 어댑터에 모은다. 호출자는 가드 클로즈로 적중 값을 먼저 반환한 뒤 미적중과 장애에 맞는 조회 정책을 고른다. 호출자 토큰의 취소는 이 결과값으로 바꾸지 않고 호출 스택으로 전파한다.
public enum CacheStatus { Hit, Miss, Down }
public readonly record struct CacheRead<T>(CacheStatus Status, T? Value);
// 어댑터 경계: 여기서만 try/catch로 인프라 실패를 Result로 바꾼다.
public async Task<CacheRead<ProductDto>> TryReadAsync(string key, CancellationToken ct)
{
try
{
var cached = await cache.GetAsync<ProductDto>(key, ct);
return cached is null
? new CacheRead<ProductDto>(CacheStatus.Miss, null)
: new CacheRead<ProductDto>(CacheStatus.Hit, cached);
}
catch (OperationCanceledException) when (ct.IsCancellationRequested)
{
throw;
}
catch (Exception ex)
{
logger.LogWarning(ex, "Cache read failed. key={CacheKey}", key);
return new CacheRead<ProductDto>(CacheStatus.Down, null);
}
}
public async Task<ProductDto?> GetProductAsync(long productId, CancellationToken ct)
{
var key = $"product:{productId}:detail:v1";
var read = await TryReadAsync(key, ct);
// 가드 클로즈: hit이면 즉시 반환한다.
if (read.Status == CacheStatus.Hit)
{
return read.Value;
}
// miss든 down이든 DB가 source of truth다. 비즈니스 로직엔 try/catch가 없다.
var product = await productRepository.FindDtoAsync(productId, ct);
if (product is null)
{
return null;
}
// 캐시가 down이면 굳이 쓰기를 시도하지 않는다. miss일 때만 채운다.
if (read.Status == CacheStatus.Miss)
{
await TryWriteAsync(key, product, TimeSpan.FromMinutes(5), ct);
}
return product;
}
이렇게 하면 에러 정책이 한곳(어댑터 경계)으로 모인다. 비즈니스 로직은 Hit / Miss / Down 세 상태를 명시적으로 분기할 뿐, 인프라 예외를 직접 처리하지 않는다. miss와 down을 구분하므로 "캐시가 죽었을 때는 쓰기를 건너뛴다" 같은 정책도 자연스럽게 표현된다.
다만 위 CacheRead<T>는 T? Value라서, C# 컴파일러가 Status == Hit일 때 Value가 non-null임을 자동으로 추론하지 못한다. 반환형이 non-nullable이라면 nullable 경고가 날 수 있으므로 read.Value!로 단언하거나, Hit/Miss/Down을 전용 union type(또는 helper 메서드)으로 감싸 상태와 값의 관계를 타입으로 강제하는 편이 낫다.
Read-Through, Write-Through와 차이
Cache-Aside와 Read-Through는 캐시 미스 때 원본 조회를 누가 맡는지 비교한다. Write-Through·Write-Behind·Write-Around는 쓰기를 어떤 경로로 보내고 언제 성공을 돌려주는지 정하므로, 읽기 전략과 쓰기 전략을 나눠 조합해서 선택한다.
패턴 | 원본 저장소 접근 책임 | 특징 |
|---|---|---|
Cache-Aside | 애플리케이션 | 가장 흔하고 단순하다. 앱 코드가 책임을 많이 진다 |
Read-Through | 캐시 계층 | 앱은 캐시만 본다. 캐시 구현이 복잡해진다 |
Write-Through | 캐시/저장 계층 | 쓰기 시 캐시와 저장소를 함께 갱신한다 |
Write-Behind | 캐시/큐/백그라운드 | 빠르지만 데이터 손실과 일관성 설계가 어렵다 |
- 패턴
Cache-Aside
- 원본 저장소 접근 책임
애플리케이션
- 특징
가장 흔하고 단순하다. 앱 코드가 책임을 많이 진다
- 패턴
Read-Through
- 원본 저장소 접근 책임
캐시 계층
- 특징
앱은 캐시만 본다. 캐시 구현이 복잡해진다
- 패턴
Write-Through
- 원본 저장소 접근 책임
캐시/저장 계층
- 특징
쓰기 시 캐시와 저장소를 함께 갱신한다
- 패턴
Write-Behind
- 원본 저장소 접근 책임
캐시/큐/백그라운드
- 특징
빠르지만 데이터 손실과 일관성 설계가 어렵다
Cache-Aside를 고르면 애플리케이션이 무효화와 실패 처리를 소유한다. Write-Around를 함께 쓸 때는 DB에 직접 쓰고, 해당 값이 이미 캐시에 있다면 갱신 뒤 무효화하는 경로도 연결한다.
성능 최적화: 직렬화와 할당
지금까지 예제는 값을 JSON으로 직렬화·역직렬화한다.
디버깅이 쉽고 어디서나 통하는 기본값이지만, 읽기 빈도가 극단적으로 높은 hot key에서는 매 조회마다
문자열 할당과 JSON 파싱이 일어나 C#의 GC(특히 Gen0)에 부담을 준다. 캐시가 빨라도 GC 일시정지가 p99 지연을 끌어올릴 수 있다.
언제 바꿀지는 정해진 상수가 아니라 측정으로 정한다. 먼저 재야 할 신호는 이것들이다.
할당률(allocation rate)과 Gen0 수집 빈도가 CPU의 유의미한 비율을 차지하는가
p99·p999 지연 스파이크가 GC 일시정지와 상관되는가
그 hot key의 QPS와 payload 크기(수 KB 이상이면 파싱 비용이 커진다)
직렬화 비용이 지연 예산(latency budget) 안에 들어오는가
JSON을 유지할지 바꿀지는 측정 결과로 정한다. 할당이나 파싱이 hot key의 지연 예산을 넘는 경로부터 개선하고, 각 변경 뒤 지연과 메모리를 다시 비교한다.
JSON을 유지하되 비용 절감: System.Text.Json source generator로 리플렉션을 없애고,
Utf8JsonReader로 Redis가 준 바이트(RedisValue)를 중간string생성 없이 바로 파싱한다.15바이너리 프로토콜: 크기와 속도가 더 필요하면 MessagePack이나 Protobuf로 바꾼다. payload가 작아지고 파싱이 빨라지지만 사람이 읽기 어려워지고, key 버전 관리(Key 설계)가 더 중요해진다.
Zero-allocation 읽기: 레이아웃이 고정된 값이라면
Span<T>·Memory<T>와ArrayPool<byte>풀링으로 역직렬화 과정의 힙 할당을 거의 0으로 만든다.
바이트 파싱, 바이너리 형식, 버퍼 재사용은 측정에서 드러난 병목에 맞춰 고른다. 적용한 변경이 평균과 꼬리 지연, 할당량에 어떤 차이를 냈는지 확인하고 효과가 있는 범위까지만 유지한다.
성능 최적화 보충설명
P99와 P999 (Tail Latency, 꼬리 지연시간) 성능을 측정할 때 '평균 응답 시간(Average Latency)'은 거짓말을 한다. 평균은 대다수의 빠른 요청에 묻혀, 시스템을 망가뜨리는 소수의 극단적인 지연(Outlier)을 완벽하게 숨기기 때문이다. 보통 평균 대신 백분위수(Percentile)를 본다.
P99는 관측 구간의 요청 지연을 빠른 순서로 정렬했을 때 99백분위에 해당하는 경계값이다. P99가 50ms이면 측정 도구가 그 구간의 99백분위 지연을 50ms로 집계했다는 뜻이며, 사용자 수가 아니라 요청 지연의 분포를 읽는다.
P99.9는 같은 분포의 99.9백분위 경계값이다. 같은 지연값의 반복과 도구의 보간 방식에 따라 경계보다 느린 관측치의 비율이 달라진다.
GC 일시정지와 지연 스파이크가 함께 나타나는지 확인하려면 요청 지연 분포와 GC·CPU 지표를 같은 시간축에서 본다. 평균이 빠른 서비스에서도 일부 요청은 오래 걸릴 수 있으므로, hot key의 직렬화 변경은 평균과 P99·P99.9를 함께 비교해 평가한다.
자주 하는 오해
읽기 전략과 쓰기 전략은 한 목록에서 하나만 고르는가?
읽기에서는 Cache-Aside와 Read-Through로 미스 처리의 주체를 정하고, 쓰기에서는 Write-Around·Write-Through·Write-Behind로 반영 경로와 성공 응답 시점을 정한다. 예를 들어 Cache-Aside로 읽고 DB에 직접 쓴 뒤 캐시를 지우는 흐름을 함께 구성할 수 있다.
Read-Through를 쓰면 매번 DB의 최신값을 읽는가?
Read-Through는 미스가 났을 때 캐시 계층이 원본을 조회한다. 적중이면 캐시 값을 돌려주므로, 원본에 직접 들어온 변경을 반영하려면 무효화나 갱신 경로를 연결해야 한다. DAX도 직접 DynamoDB에 쓴 변경과 질의 결과 캐시의 만료를 구별해 설명한다. DAX 일관성 모델
Write-Through와 Write-Behind는 언제 쓰기가 끝나는가?
Write-Through는 원본 저장 완료를 기다린 뒤 성공을 돌려주고, 두 저장소 사이에서 부분 실패가 나면 그 복구 방법까지 정해야 한다. Write-Behind는 원본 반영을 뒤로 미루므로 성공 응답 뒤에도 아직 반영하지 않은 쓰기가 남을 수 있다. 이때 캐시나 큐는 미반영 쓰기를 잃지 않도록 내구성과 재처리 정책을 갖춰야 한다. 캐시 쓰기 경로와 일관성
TTL을 짧게 잡으면 최신성과 용량 문제가 함께 해결되는가?
TTL은 캐시에 넣은 값의 만료 시간을 정한다. DB 변경 통지, 늦게 끝난 읽기의 저장 순서, 복제 지연은 각각 갱신 경로에서 다룬다. 메모리 부족 시 어떤 키를 지울지는 eviction 정책이 정하고, noeviction에서는 추가 메모리를 요구하는 쓰기가 거절된다. Redis eviction 정책
워밍은 데이터를 많이 미리 넣을수록 좋은가?
워밍은 시작·재시작 때 예상되는 미스를 앞당겨 처리하는 작업이다. 자주 읽을 작은 키 집합부터 원본 저장소가 감당할 동시성으로 채우고, 실제 적중률과 용량을 보며 범위를 넓힌다. 전체 데이터를 한꺼번에 읽으면 워밍 자체가 DB 부하를 만들고 곧 밀려날 값까지 채우게 된다. 캐시 대상 선택 기준
캐시 장애 때 DB fallback과 회로 하나면 충분한가?
캐시 회로는 캐시 호출의 실패를, DB 회로는 DB 호출의 실패를 관측하게 나눈다. 캐시 실패 뒤 DB 조회가 성공하면 전체 요청만 보는 회로에는 성공으로 기록될 수 있으므로, DB로 유입되는 조회량도 별도로 제한한다. 원본 저장소의 여유와 사용자 응답 예산에 맞춰 동시성 제한, 빠른 실패, 허용한 축소 응답을 조합한다.
언제 쓰면 안 되는가?
항상 최신 데이터가 필요할 때
캐시 무효화 기준을 정할 수 없을 때
쓰기가 매우 잦고 읽기 재사용이 적을 때
데이터마다 TTL과 일관성 요구가 다른데 하나의 정책으로 밀어붙일 때
캐시 장애가 전체 장애로 번질 때
캐시 key가 사용자 권한이나 tenant 경계를 제대로 반영하지 못할 때
특히 권한과 개인정보는 조심해야 한다. user:{id} 같은 key만 쓰면 tenant, role, locale, permission scope가 빠져서 다른 사용자에게 잘못된 데이터가 보일 수 있다.
보안과 권한 경계
캐시 키에서 사용자나 조직별 데이터 범위를 구분하지 않으면, 캐시 적중 시 다른 호출자의 데이터가 노출될 수 있다.
아래 항목으로 데이터 범위와 권한 확인을 점검한다.
tenant ID 없는 key 금지. 멀티테넌시면 key에 tenant를 반드시 포함한다.
user ID만으로 권한을 캐싱하지 않는다. role, scope, locale, 버전을 key에 넣는다.
권한 캐시는 최종 판정용이 아니라 힌트로만 쓰고, 민감한 결정은 권한 서버나 DB에서 다시 확인한다.
개인정보(PII)가 든 payload는 암호화 여부를 검토하고, 캐시 로그·트레이스에 PII를 남기지 않는다.
Redis 접근 자체를 보호한다. ACL로 권한을 최소화하고, 전송 구간은 TLS로 감싼다.
특히 권한 축소, 조직 이동, 구독 해지, 결제 취소처럼 권리가 줄어드는 이벤트는 TTL 만료를 기다리지 말고 즉시 invalidation해야 한다. 권한 캐시에서 진짜 위험한 사고는 대개 권한 부여보다 권한 회수가 늦어질 때 터진다.
캐시 키는 데이터가 유효한 사용자·조직·권한 범위를 구분해야 한다. 키가 맞는다는 이유만으로 접근을 허용해서는 안 된다.
결국 프로그램 설계의 상당수는 경계를 어떻게 설정하느냐의 문제다. 캐시에서는 키가 접근 범위의 경계를 가르고 호출자 인가 검사가 실제 권한을 확인하므로, 이 경계를 어디까지 정밀하게 잡느냐가 중요하다.
체크리스트
Cache-Aside를 넣기 전에 확인할 것:
이 데이터는 반복 조회되는가?
stale data 허용 시간이 명확한가?
key에 도메인, 식별자, 조회 모양, 버전이 들어가는가?
쓰기 후 어떤 key를 지울지 정해져 있는가?
cache stampede를 막을 방법이 있는가?
캐시 장애 시 DB fallback이 가능한가?
캐시 hit ratio, miss ratio, latency를 볼 수 있는가?
캐시 값에 개인정보나 권한 경계가 섞이지 않는가?
체크리스트의 "hit ratio, miss ratio, latency를 볼 수 있는가"는 그것을 어떻게 볼지가 관건이다. Cache-Aside는 애플리케이션이 제어권을 쥐므로, Redis 서버 메트릭만 봐서는 어떤 엔드포인트나 비즈니스 로직이 캐시를 뚫고 DB 부하를 만드는지 알기 어렵다. OpenTelemetry16 같은 분산 추적을 도입해서 캐시 조회 구간에 명시적 Span을 만들고, hit/miss를 태그로 기록한 뒤 그 아래 DB 쿼리 트레이스와 연결(correlation)하면, "어느 경로의 miss가 DB를 때리는가"를 추적 단위로 짚을수 있다.
인프라 메트릭(서버 hit ratio)과 애플리케이션 추적(엔드포인트별 hit/miss)을 함께 봐야 Cache-Aside의 제어 책임에 맞는 관측성이 완성된다.
간단 요약
Cache-Aside에서는 반복 조회를 캐시로 흡수하고 원본 저장소가 기준 데이터를 소유한다. 이 구조를 운영하려면 갱신 시 무효화, 데이터별 허용 지연, 캐시가 비었을 때의 DB 유입량과 권한별 키 범위를 함께 정해야 한다.
같이 보기
참고문헌
Microsoft Azure Architecture Center. Caching guidance
분류: 프로그래밍 패턴 | 운영 패턴 | 캐싱 | WIKI
각주
- Microsoft Azure Architecture Center. Cache-Aside pattern ↩
- AWS. Caching Best Practices: Lazy caching ↩
- AWS Whitepaper. Database Caching Strategies Using Redis: Cache-Aside. AWS 문서 자체는 일부 whitepaper가 historical reference로 표시될 수 있으므로, 개념 참고용으로 본다. ↩
- Redis. Caching solutions: cache aside ↩
- Redis. Key eviction (maxmemory-policy) ↩
- Redis. Memory optimization (activedefrag, mem_fragmentation_ratio) ↩
- Redis. Distributed Locks with Redis (Redlock): token과 안전 해제 ↩
- Kleppmann, M. How to do distributed locking. 분산 락의 한계와 fencing token 논의. ↩
- Redis. Scripting with Lua (EVAL): 스크립트의 원자적 실행 ↩
- Redis. Redis cluster specification: hash tags와 키 슬롯 ↩
- Redis. CLUSTER KEYSLOT ↩
- Vattani, A., Chierichetti, F., Lowenstein, K. Optimal Probabilistic Cache Stampede Prevention. PVLDB 8(8), 886-897, 2015. (PER / XFetch) ↩
- Microsoft Learn. System.Threading.Channels library ↩
- Microsoft Azure Architecture Center. Circuit Breaker pattern ↩
- Microsoft Learn. System.Text.Json source generation ↩
- OpenTelemetry. Traces (Span, 속성, context propagation) ↩