Câu hỏi “in-memory hay phân tán” thường được trả lời bằng số lượng server: một server thì in-memory, nhiều server thì Redis. Cách trả lời đó đúng nhưng thiếu một nửa sự thật — nó bỏ qua việc process của bạn có thể chết, deploy cuốn mất cache, và dữ liệu bạn đang giữ có được phép cũ hay không.
Bài này so sánh hai mô hình theo những gì chúng thực sự đảm bảo, đưa ra bảng quyết định theo tình huống, và chỉ đường migration từ IMemoryCache sang HybridCache.
Mục lục
Cập nhật 2026
HybridCache(Microsoft.Extensions.Caching.Hybrid10.11.0) cho dùng cả hai mô hình cùng lúc: L1 in-process, L2 phân tán, kèm stampede protection.- Redis 8.x là server phân tán phổ biến;
IDistributedCachequaMicrosoft.Extensions.Caching.StackExchangeRedis10.0.14. - Session và SignalR scale-out vẫn cần store/backplane chia sẻ; sticky session không phải giải pháp kiến trúc.
- .NET 8/9 hết hỗ trợ 2026-11-10; khi nâng cấp, chọn mô hình cache theo kiến trúc mục tiêu thay vì giữ lựa chọn cũ.
Hai mô hình, một câu hỏi: dữ liệu nào cần chia sẻ
Cache in-memory sống trong heap của process: nhanh nhất, không serialize, không round-trip mạng, nhưng chỉ process đó thấy. Cache phân tán sống ngoài process, mọi instance thấy cùng một bản, đổi lại là network, serialization và một dependency mới có thể hỏng.
Tiêu chí chọn không phải “bao nhiêu server”, mà là ba câu hỏi:
- Dữ liệu có cần giống nhau giữa các instance không? Session, cấu hình động, bộ đếm rate limit, lock — có. Danh mục sản phẩm ít đổi — không nhất thiết.
- Mất cache có làm hỏng chức năng không? Cache đọc thì không; session thì có; lock thì rất có.
- Dữ liệu cũ trong bao lâu là chấp nhận được? Đây là con số bạn phải viết ra, vì cả hai mô hình đều trả về dữ liệu cũ ít nhất vài giây.
Điểm dễ nhầm: cache phân tán không có nghĩa là nhất quán với database. Nó chỉ có nghĩa là các instance thấy cùng một bản cache. Database vẫn là nguồn sự thật, và mọi cache đều có thể lệch cho đến khi hết TTL hoặc bị xóa.
In-memory thực sự cho bạn gì
Với IMemoryCache, chi phí đọc gần như bằng một lookup dictionary. Nhưng mặc định nó không có giới hạn kích thước: nhét mọi thứ vào thì heap phình đến khi container bị OOMKill hoặc GC chạy liên tục. Trong Kubernetes, giới hạn bộ nhớ của pod là giới hạn thật, vượt nó là restart.
Hai thiết lập bắt buộc: SizeLimit trên MemoryCacheOptions và SetSize cho từng entry lớn. Đơn vị của Size do bạn quy ước — số entry hoặc byte ước lượng — miễn là nhất quán. Khi vượt SizeLimit, cache compaction và đẩy các entry ít ưu tiên ra.
// File: Program.cs
builder.Services.AddMemoryCache(options =>
{
options.SizeLimit = 50_000; // tổng "size" tối đa
options.CompactionPercentage = 0.25; // giải phóng 25% khi vượt
});
// File: Features/Catalog/CatalogCache.cs
public sealed class CatalogCache(IMemoryCache cache, AppDbContext db)
{
public async Task<ProductDto?> GetAsync(int id, CancellationToken ct)
{
var key = $"catalog:product:{id}";
if (cache.TryGetValue<ProductDto>(key, out var hit))
return hit;
var dto = await db.Products.AsNoTracking()
.Where(p => p.Id == id)
.Select(p => new ProductDto(p.Id, p.Name, p.Price))
.FirstOrDefaultAsync(ct);
if (dto is not null)
{
cache.Set(key, dto, new MemoryCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5),
Size = 1,
Priority = CacheItemPriority.Normal
});
}
return dto;
}
}
Điều in-memory không cho bạn: dữ liệu sống qua restart, chia sẻ giữa các instance, và một chỗ để vô hiệu hóa từ bên ngoài. Nếu bạn chạy hai container sau load balancer, hai bản cache sẽ khác nhau, và người dùng thấy dữ liệu khác nhau tùy container — lỗi chỉ xuất hiện khi scale, không xuất hiện khi dev.
Cache phân tán thực sự cho bạn gì
Cache phân tán đưa dữ liệu ra khỏi process. Lợi ích thật là ba thứ: một bản duy nhất cho mọi instance, sống qua deploy và restart, và có thể mở rộng độc lập với ứng dụng. Cái giá cũng ba thứ: thêm round-trip mạng, thêm serialize/deserialize, và thêm một thành phần có thể lỗi.
Với Redis, mọi giá trị đều đi qua byte[] — kể cả khi bạn dùng HybridCache, nó vẫn serialize giúp bạn. Điều này có nghĩa là DTO phải ổn định theo thời gian: thêm field có default thì đọc được bản cũ, đổi kiểu hoặc đổi tên thì không. Hãy đặt version trong key hoặc trong payload khi schema còn thay đổi.
// File: Program.cs
builder.Services.AddStackExchangeRedisCache(options =>
{
options.Configuration = builder.Configuration.GetConnectionString("Redis");
options.InstanceName = "app:";
});
builder.Services.AddHybridCache(options =>
{
options.DefaultEntryOptions = new HybridCacheEntryOptions
{
Expiration = TimeSpan.FromMinutes(10), // L2
LocalCacheExpiration = TimeSpan.FromSeconds(15) // L1
};
});
Nếu bạn chỉ cần một chỗ lưu key-value cho session, IDistributedCache là đủ. Nếu bạn cần đọc dữ liệu với logic get-or-create, stampede protection và L1, HybridCache là lựa chọn đúng và không cần tự viết lại.
Nhất quán, sticky session và cái bẫy quen thuộc
Sticky session (session affinity) giữ người dùng trên cùng một instance để cache in-memory hoạt động. Nó có thể là giải pháp tạm, không phải kiến trúc: deploy rolling sẽ đẩy người dùng sang instance khác, autoscaling thêm instance rỗng, và một instance chết là mất session của những người đang gắn vào nó. Nếu bạn cần session, hãy dùng store chia sẻ; nếu bạn cần real-time, hãy dùng backplane cho SignalR.
Với cache đọc, nhất quán là một quyết định sản phẩm, không phải kỹ thuật. Ví dụ: giá sản phẩm có được phép cũ 30 giây không? Nếu có, cache in-memory 30 giây mỗi node là chấp nhận được và rẻ nhất. Nếu không, bạn cần một bản chia sẻ và invalidation chủ động khi ghi — và vẫn phải chấp nhận một khe thời gian nhỏ.
Ba mô hình nhất quán thường gặp:
| Mô hình | Độ cũ tối đa | Phù hợp |
|---|---|---|
| Per-node, chỉ TTL | TTL mỗi node | Dữ liệu tham chiếu, ít đổi, chấp nhận lệch giữa node |
| Chia sẻ, xóa khi ghi | Từ lúc xóa đến lúc node đọc lại | Dữ liệu cần thống nhất giữa các instance |
| HybridCache L1 + L2 | tối đa LocalCacheExpiration |
Cần tốc độ L1 nhưng vẫn có bản chia sẻ |
Hàng giữa là mô hình phổ biến nhất trong hệ nhiều instance: Redis giữ bản chung, mỗi lần ghi thì xóa key. Nó đúng miễn là mọi đường ghi đều đi qua ứng dụng và bạn chấp nhận khoảng thời gian giữa commit và xóa.
L1/L2: dùng cả hai mà không tự lừa mình
HybridCache giải quyết đúng bài toán “muốn nhanh như in-memory nhưng cần chia sẻ”. L1 là bộ nhớ trong process, L2 là IDistributedCache bạn đăng ký. Đọc đầu tiên đi L1; miss L1 thì đọc L2; miss cả hai thì gọi factory và ghi ngược lên cả hai.
Điều quan trọng: LocalCacheExpiration là trần độ cũ trên mỗi node. RemoveAsync chỉ xóa L1 của process gọi nó và L2; các node khác vẫn giữ bản L1 cũ đến khi hết hạn. Nếu cần invalidation tức thời giữa các node, phải thêm pub/sub hoặc backplane — và chấp nhận nó có thể mất message. Với phần lớn dữ liệu đọc, L1 10–30 giây là đủ và rẻ hơn nhiều so với backplane.
// File: Features/Catalog/HybridCatalog.cs
using Microsoft.Extensions.Caching.Hybrid;
public sealed class HybridCatalog(IHybridCache cache, AppDbContext db)
{
public async Task<ProductDto?> GetAsync(Guid tenantId, int id, CancellationToken ct) =>
await cache.GetOrCreateAsync(
$"app:{tenantId}:product:{id}",
async token => await db.Products.AsNoTracking()
.Where(p => p.TenantId == tenantId && p.Id == id)
.Select(p => new ProductDto(p.Id, p.Name, p.Price))
.FirstOrDefaultAsync(token),
cancellationToken: ct);
}
Cold start, deploy và cơn bão đầu tiên
Cache in-memory chết theo process. Mỗi deploy, mỗi lần scale out, mỗi lần pod restart, node mới bắt đầu với cache rỗng. Nếu dữ liệu đọc nặng, đây là lúc database nhận một đợt sóng — và nếu tất cả node restart cùng lúc, đó là thundering herd.
Cache phân tán sống qua restart ứng dụng, nên L2 vẫn ấm sau deploy. Nhưng nếu cả Redis restart hoặc bị flush, bạn gặp đúng vấn đề đó ở quy mô lớn hơn. Ba biện pháp: jitter TTL, stampede protection của HybridCache, và warm-up nền có giới hạn cho một số key quan trọng — không phải vòng lặp đọc toàn bộ bảng lúc khởi động.
Với rolling deploy, hãy đảm bảo phiên bản cũ và mới đọc được cùng định dạng cache. Nếu DTO đổi cấu trúc, dùng version trong key để bản mới không đọc nhầm payload của bản cũ trong lúc deploy.
Khi Redis chết: mô hình nào sập thế nào
Cache in-memory gần như không có failure mode riêng: nó chết cùng process. Cache phân tán thì có. Redis timeout hoặc mất kết nối sẽ làm mọi lời gọi cache ném exception nếu bạn không xử lý; nếu bạn để exception đi lên, một sự cố cache biến thành sự cố API.
Ba mức xử lý, chọn theo vai trò dữ liệu:
- Cache đọc: bọc trong try/catch, log, fallback database. Chấp nhận chậm hơn khi Redis lỗi; đừng chấp nhận 500.
- Session: đây là dependency thật. Redis lỗi nghĩa là người dùng bị đăng xuất; cần quyết định trước, hoặc có cơ chế dự phòng.
- Lock/rate limit: đừng fail open mặc định. Rate limit fail open có thể khiến hệ thống bị lũ; lock fail open có thể tạo ghi trùng.
Cấu hình giúp giảm sự cố: AbortOnConnectFail = false để ứng dụng khởi động được khi Redis chưa lên, timeout rõ ràng để không treo request, và circuit breaker để ngừng gọi Redis trong một khoảng khi lỗi liên tiếp. Nếu dùng Polly, đặt AddStandardResilienceHandler trên HttpClient không giúp gì cho Redis; hãy tự bọc lớp cache hoặc dùng timeout và breaker của client.
Dung lượng, eviction và chi phí thật
In-memory: dung lượng bị giới hạn bởi heap của từng instance, và bị nhân lên N lần khi scale. Cache 200 MB trên mỗi node với 10 node là 2 GB RAM trả tiền, cộng thêm áp lực GC. Đổi lại, không có network và không serialize.
Phân tán: một bản duy nhất, dung lượng do bạn cấp cho Redis, nhưng mỗi lần đọc có round-trip và serialize. Với payload lớn hoặc key nóng cực cao, network và CPU serialize là chi phí đáng kể. Redis eviction (allkeys-lru) có thể đẩy key nóng ra nếu cấp thiếu bộ nhớ; theo dõi evicted_keys.
Chi phí vận hành cũng khác: Redis managed có giá, có bản vá, có backup, có sự cố cần trực; in-memory “miễn phí” nhưng nằm trong bill compute và có thể gây OOMKill khó truy. Đừng so sánh chỉ giá Redis với 0.
Bảng quyết định
| Tình huống | Chọn | Lý do |
|---|---|---|
| Một instance, dữ liệu đọc ít đổi | IMemoryCache hoặc L1 trong HybridCache | Rẻ nhất, không cần hạ tầng thêm |
| Nhiều instance, dữ liệu tham chiếu | HybridCache L1 ngắn + L2 Redis | Tốc độ L1, có bản chia sẻ |
| Session, rate limit, lock | Redis trực tiếp qua IDistributedCache/IDatabase | Cần một bản chung và TTL/atomic |
| Dữ liệu phải mới ngay sau ghi | Không cache, hoặc write-through + invalidation | Cache không giải quyết nhất quán mạnh |
| Payload rất lớn, hit rate thấp | Không cache; tối ưu query trước | Serialize và bộ nhớ tốn hơn lợi ích |
Migration từ IMemoryCache
Đường migration ít rủi ro nhất là thay dần theo module, không big-bang:
- Đo trước: hit ratio, p95 latency, số query DB của module. Không có số thì không biết migration có cải thiện gì.
- Đưa mọi lời gọi cache qua một lớp mỏng hoặc chuyển thẳng sang
IHybridCacheđể có một chỗ đổi key, TTL và serialization. - Chuẩn hóa key trước khi chuyển: tiền tố ứng dụng, tenant, version. Key cũ không có tenant sẽ va chạm khi chạy nhiều tenant trên cùng Redis.
- Chuyển sang
HybridCachevới L1 ngắn và L2 Redis, giữ nguyên TTL hiệu dụng để so sánh. - Kiểm tra nhánh dữ liệu không tồn tại:
IMemoryCachetrảfalse,HybridCachetrả giá trị factory. - Đo lại sau 1–2 tuần, đặc biệt p95 và
evicted_keys. Hit ratio giảm nghĩa là L1 quá ngắn hoặc key bị đổi tên.
Một điểm dễ vỡ: TTL. MemoryCacheEntryOptions nhận TimeSpan tương đối hoặc DateTimeOffset tuyệt đối; HybridCacheEntryOptions tách L1 và L2. Nếu bạn đang dựa vào sliding expiration, hãy kiểm tra lại ngữ nghĩa trên L2 — với Redis, sliding cần RefreshAsync và không tự động như bạn tưởng.
2027: mặc định sẽ là cache hai tầng
.NET 11 dự kiến GA tháng 11/2026 (STS), và HybridCache đã là hướng mặc định trong .NET 10. Kỳ vọng là invalidation và telemetry được chuẩn hóa hơn; việc chọn Redis hay in-memory vẫn là quyết định kiến trúc: dữ liệu nào chia sẻ, cũ bao lâu, và chấp nhận mất gì khi cache lỗi.
Checklist
- Viết ra “dữ liệu cũ tối đa bao lâu” cho từng nhóm dữ liệu trước khi chọn mô hình.
- Đặt
SizeLimitchoIMemoryCache; với Redis, đặtmaxmemoryvà policy phù hợp. - Không dùng sticky session làm kiến trúc; session và SignalR cần store/backplane chia sẻ.
- HybridCache: L1 10–30 giây cho dữ liệu hay đổi, L2 dài hơn; xóa không lan tới L1 các node khác.
- Có fallback khi Redis lỗi cho cache đọc; quyết định fail open hay fail closed cho rate limit và lock.
- Migration theo module, có số đo trước và sau; không đổi key và TTL cùng lúc.
Đọc tiếp: Các chiến lược cache trong ASP.NET Core để chọn cache-aside hay write-through; Sử dụng Redis trong ASP.NET Core để triển khai L2; và Cache với Memcached để so sánh một lựa chọn phân tán đơn giản hơn.



