Sử dụng Redis trong ASP.NET Core: Bắt Đầu Nhanh và Các Mẫu Thiết Kế Phổ Biến

Redis trong ASP.NET Core không khó ở chỗ kết nối. Khó ở chỗ chọn cấu trúc dữ liệu, đặt TTL, và quyết định dữ liệu nào được phép nằm trong bộ nhớ. Một IConnectionMultiplexer dùng sai cách sẽ tạo hàng trăm kết nối; một key không có TTL sẽ ăn hết RAM; một lock thiếu hiểu biết sẽ cho bạn cảm giác an toàn giả.

Bài này là bản bắt đầu nhanh với Redis 8.x và StackExchange.Redis 3.4.31, kèm các mẫu thực dụng: cache-aside, session, leaderboard, pub/sub, Lua và cluster.

Cập nhật 2026

  • Redis server hiện hành là 8.x. Các module search, JSON, time series và probabilistic trước đây thuộc Redis Stack đã có trong Redis 8.
  • StackExchange.Redis 3.4.31 là client chính; Microsoft.Extensions.Caching.StackExchangeRedis 10.0.14 là implementation IDistributedCache cho .NET 10.
  • HybridCache (Microsoft.Extensions.Caching.Hybrid 10.11.0) dùng Redis làm L2; với cache đọc thông thường, đây là API nên bắt đầu thay vì gọi IDatabase thô.
  • Redis single-node lock vẫn không đủ cho distributed lock nghiêm túc; cần consensus hoặc fencing token, không chỉ SET NX.

Redis 8 làm được gì trong một ứng dụng .NET

Redis là data structure store trong bộ nhớ. Ngoài string, nó có hash, list, set, sorted set, stream, bitmap, HyperLogLog và geospatial. Mỗi lệnh được xử lý tuần tự trên luồng chính của node, nên KEYS hoặc một lệnh O(N) sẽ chặn mọi client khác — đừng chạy chúng trên production.

Trong ứng dụng ASP.NET Core, Redis thường giữ năm vai trò: cache dữ liệu đọc, session store, rate limit, leaderboard hoặc thống kê, và pub/sub cho invalidation. Nó cũng làm lock và queue, nhưng cần đọc caveat bên dưới.

Kết nối: một IConnectionMultiplexer cho cả ứng dụng

ConnectionMultiplexer là thread-safe và tự quản lý pool kết nối bên trong. Tạo nó một lần và chia sẻ qua DI; GetDatabase() rất rẻ, gọi mỗi lần dùng cũng không sao. Sai lầm phổ biến là tạo multiplexer trong từng controller hoặc mỗi request — mỗi lần như vậy là một bộ kết nối mới kèm reconnect và timeout riêng.

Đặt AbortOnConnectFail = false để ứng dụng vẫn khởi động khi Redis chưa sẵn sàng; client sẽ thử lại ở nền. Đặt ClientName để thấy ai đang giữ kết nối trong CLIENT LIST. Với managed Redis hoặc TLS, dùng ConfigurationOptions thay vì chuỗi connection string thuần để bật Ssl, User, Password rõ ràng.

// File: Program.cs
using Microsoft.Extensions.Caching.Distributed;
using StackExchange.Redis;

var builder = WebApplication.CreateBuilder(args);

var options = ConfigurationOptions.Parse(
    builder.Configuration.GetConnectionString("Redis") ?? "localhost:6379");
options.AbortOnConnectFail = false;
options.ClientName = "catalog-api";
options.ConnectRetry = 3;

var mux = await ConnectionMultiplexer.ConnectAsync(options);

builder.Services.AddSingleton<IConnectionMultiplexer>(mux);

// IDistributedCache dùng chung multiplexer thay vì mở bộ kết nối thứ hai
builder.Services.AddStackExchangeRedisCache(cache =>
{
    cache.ConnectionMultiplexerFactory = () => Task.FromResult<IConnectionMultiplexer>(mux);
    cache.InstanceName = "catalog:";
});

InstanceName là tiền tố mà implementation IDistributedCache ghép vào mọi key. Nếu nhiều ứng dụng dùng chung một Redis, hãy đặt tiền tố riêng cho từng ứng dụng và môi trường; nếu không, staging và production sẽ ghi đè key của nhau.

IDistributedCache chỉ làm việc với byte[]: không get-or-create, không CAS, không thao tác nhiều key nguyên tử. Nó đủ cho session và data protection, nhưng không đủ cho logic cần atomic; khi cần những thứ đó, dùng IDatabase hoặc HybridCache.

Key, serialization và TTL

Key nên có cấu trúc cố định, tenant ở đầu: app:{tenant}:{entity}:{id}:v{version}. Vài quy tắc:

  • Ngắn nhưng đọc được: mỗi key tốn bộ nhớ và metadata; tiền tố dài trên hàng triệu key là chi phí thật.
  • Không chứa dữ liệu nhạy cảm: key hiện trong log, MONITOR, SCAN và dashboard.
  • Hash tag khi chạy cluster: {tenant:42}:cart giữ các key liên quan trong cùng slot để Lua và thao tác nhiều key chạy được.
  • Luôn có TTL, trừ dữ liệu thật sự vĩnh viễn như cấu hình phiên bản.

Serialize DTO, không serialize entity của EF Core. Entity có navigation property, proxy lazy loading và vòng tham chiếu; cache nó là cách nhanh nhất để tạo payload lớn và lỗi khó tái hiện. System.Text.Json là mặc định tốt; với DTO nóng, dùng source generator (JsonSerializerContext) để bỏ chi phí reflection. MessagePack cho payload nhỏ hơn, nhưng schema kém linh hoạt hơn — thêm field có default vẫn đọc được, đổi kiểu thì không.

// File: Features/Catalog/RedisProductCache.cs
using System.Text.Json;
using StackExchange.Redis;

public sealed class RedisProductCache(IConnectionMultiplexer mux)
{
    private static readonly TimeSpan Ttl = TimeSpan.FromMinutes(10);
    private readonly IDatabase _db = mux.GetDatabase();

    public async Task<ProductDto?> GetAsync(Guid tenantId, int id, CancellationToken ct)
    {
        var key = $"app:{tenantId}:product:{id}";
        var json = await _db.StringGetAsync(key);

        return json.IsNullOrEmpty
            ? null
            : JsonSerializer.Deserialize<ProductDto>((string)json);
    }

    public Task SetAsync(Guid tenantId, int id, ProductDto dto) =>
        _db.StringSetAsync(
            $"app:{tenantId}:product:{id}",
            JsonSerializer.Serialize(dto),
            Ttl);

    // Gọi sau khi transaction ghi DB đã commit
    public Task InvalidateAsync(Guid tenantId, int id) =>
        _db.KeyDeleteAsync($"app:{tenantId}:product:{id}");
}

Hash, sorted set và các cấu trúc hay dùng

Hash phù hợp cho object có nhiều field cần cập nhật riêng: đổi giá không cần ghi lại toàn bộ JSON, và đọc một field không kéo cả object. Nhược điểm là phải tự serialize từng field, và không có TTL theo field (chỉ TTL theo key).

Sorted set là lựa chọn cho leaderboard, xếp hạng theo điểm, hoặc cửa sổ thời gian: ZINCRBY cộng điểm nguyên tử, ZREVRANGE lấy top N. Đây là thứ mà cache key-value thuần không làm được.

// File: Features/Leaderboard/LeaderboardService.cs
using StackExchange.Redis;

public sealed class LeaderboardService(IConnectionMultiplexer mux)
{
    private readonly IDatabase _db = mux.GetDatabase();

    public Task AddScoreAsync(Guid tenantId, string userId, double points) =>
        _db.SortedSetIncrementAsync($"app:{tenantId}:leaderboard:daily", userId, points);

    public async Task<(string UserId, double Score)[]> TopAsync(Guid tenantId, int count)
    {
        var entries = await _db.SortedSetRangeByRankWithScoresAsync(
            $"app:{tenantId}:leaderboard:daily", 0, count - 1, Order.Descending);

        return entries.Select(e => (UserId: (string)e.Element, e.Score)).ToArray();
    }

    // Hash: cập nhật một field, không ghi lại cả object
    public Task SetProfileFieldAsync(Guid tenantId, int id, string field, string value) =>
        _db.HashSetAsync($"app:{tenantId}:product:profile:{id}", field, value);
}

Đừng biến Redis thành database quan hệ. Cần join, transaction nhiều bảng hoặc báo cáo phức tạp thì dữ liệu nên ở SQL; Redis giỏi nhất với key-value, đếm, xếp hạng và tập hợp nhỏ cần truy cập nhanh.

TTL, memory policy và persistence

Mọi key cache nên có TTL. TTL là lưới an toàn cho invalidation sai và cho dữ liệu bị bỏ quên. Đặt TTL lúc ghi (StringSetAsync với expiry) rẻ hơn gọi EXPIRE riêng và tránh trường hợp ghi xong nhưng quên đặt hạn. KeyExpireAsync hữu ích khi muốn đổi TTL của key đã tồn tại, ví dụ gia hạn session.

Trên server, maxmemory và maxmemory-policy quyết định điều gì xảy ra khi đầy. noeviction trả lỗi khi ghi thêm — đúng cho instance giữ lock, queue hoặc dữ liệu không được phép mất. allkeys-lru hoặc allkeys-lfu phù hợp cho instance thuần cache. Đừng trộn cache có thể evict với lock trong cùng một instance: một cú eviction đúng lúc sẽ giải phóng lock và mở đường cho hai worker cùng ghi.

Persistence có hai chế độ chính: RDB snapshot theo khoảng thời gian, và AOF ghi lại lệnh với appendfsync là always, everysec hoặc no. RDB rẻ và gọn nhưng mất dữ liệu từ snapshot gần nhất; AOF bền hơn nhưng ghi nhiều hơn. Cả hai không thay thế backup và không biến Redis thành nguồn sự thật cho dữ liệu giao dịch. Với cache, persistence thường chỉ để giảm cơn bão sau restart.

Pub/sub: chỉ để báo hiệu, không để giao dịch

Pub/sub của Redis là fire-and-forget: không lưu message, không đảm bảo delivery, subscriber offline sẽ mất message. Nó phù hợp để báo hiệu invalidation giữa các instance — một instance vừa sửa sản phẩm, phát message để instance khác xóa L1. Nó không phù hợp cho event nghiệp vụ như “đơn hàng đã tạo”; dùng Streams, Kafka hoặc RabbitMQ cho việc cần ít nhất một lần giao.

Trong cluster, pub/sub cổ điển được broadcast tới mọi node; Redis cũng có sharded pub/sub để giới hạn phạm vi. Nếu dùng pub/sub cho invalidation, hãy chấp nhận một message có thể mất khi node restart, và vì vậy TTL vẫn phải là lưới an toàn.

// File: Caching/CacheInvalidationListener.cs
using StackExchange.Redis;

public sealed class CacheInvalidationListener(IConnectionMultiplexer mux, ILogger<CacheInvalidationListener> logger)
{
    public async Task StartAsync()
    {
        var subscriber = mux.GetSubscriber();

        await subscriber.SubscribeAsync(RedisChannel.Literal("cache:invalidate"), (_, message) =>
        {
            // message chứa key hoặc tenant cần xóa; xử lý idempotent
            logger.LogInformation("Invalidation: {Key}", (string)message);
        });
    }
}

Lua: nguyên tử khi cần nhiều lệnh

Redis chạy script Lua nguyên tử: không lệnh nào chen vào giữa script. Đây là cách đúng để làm compare-and-delete, rate limit cửa sổ cố định, hoặc cập nhật nhiều key phải nhất quán. Không dùng Lua cho việc nặng hoặc gọi mạng bên trong; script chặn cả node.

ScriptEvaluateAsync tự dùng EVALSHA sau lần đầu, nên không phải gửi lại toàn bộ script mỗi lần. Một ví dụ chuẩn — chỉ xóa lock nếu giá trị khớp token:

// File: Caching/RedisLock.cs
using StackExchange.Redis;

public static class RedisLock
{
    private const string ReleaseScript = """
        if redis.call('GET', KEYS[1]) == ARGV[1] then
            return redis.call('DEL', KEYS[1])
        else
            return 0
        end
        """;

    public static async Task<bool> TryAcquireAsync(IDatabase db, string key, string token, TimeSpan ttl) =>
        await db.StringSetAsync(key, token, ttl, when: When.NotExists);

    public static async Task<bool> ReleaseAsync(IDatabase db, string key, string token) =>
        (long)await db.ScriptEvaluateAsync(
            ReleaseScript,
            new RedisKey[] { key },
            new RedisValue[] { token }) == 1;
}

TryAcquireAsync trả về false nếu lock đang bị giữ. Cặp acquire/release này chỉ an toàn trên một node Redis và chỉ khi TTL đủ dài so với thời gian xử lý. Nếu công việc có thể chạy lâu hơn TTL, lock sẽ tự mở trong khi worker vẫn đang ghi — đó là lúc cần fencing token hoặc một ràng buộc ở database.

Redis Cluster

Cluster chia keyspace thành 16384 slot và phân slot cho các master. Client như StackExchange.Redis tự route lệnh tới node đúng, nên phần lớn code không đổi. Nhưng có ba giới hạn cần nhớ:

  • Thao tác nhiều key chỉ chạy khi các key cùng slot; dùng hash tag {tenant:42} để gom chúng lại.
  • Transaction (MULTI) cũng chỉ trong một slot. Cần nhất quán nhiều key khác slot thì phải thiết kế lại key hoặc dùng Lua với cùng hash tag.
  • KEYS và SCAN phải chạy theo từng node; lấy IServer cho từng endpoint và lặp, đừng giả định một node nhìn thấy toàn bộ cluster.

Resharding di chuyển slot giữa các node. Nếu key thiết kế tốt, việc này trong suốt; nếu bạn phụ thuộc vào thứ tự key hoặc quét toàn bộ, nó thành sự cố vận hành.

Redis Stack, search và vector

Redis 8 nhúng sẵn query engine và các module trước đây thuộc Redis Stack: JSON, search, time series và cấu trúc xác suất. Điều này mở ra hai mẫu liên quan đến ứng dụng .NET hiện đại: semantic cache cho kết quả LLM (embedding + vector similarity) và tìm kiếm văn bản có metadata filter.

Với vector, Redis hợp lý khi bạn đã có Redis trong hạ tầng và corpus vừa phải. Với corpus lớn hoặc yêu cầu recall cao, vector database chuyên dụng có thể phù hợp hơn; đừng chọn Redis chỉ vì tiện nếu chưa đo chi phí bộ nhớ của index.

Monitoring và failure

Bốn nhóm chỉ số cần xem: INFO stats với keyspace_hits/keyspace_misses; INFO memory với used_memory và evicted_keys; INFO clients với số kết nối và blocked_clients; và SLOWLOG để bắt lệnh chậm. MEMORY USAGE cho biết một key tốn bao nhiêu.

StackExchange.Redis phát sự kiện ConnectionFailed và ConnectionRestored; hãy log và đưa vào metric. Hai exception cần phân biệt: RedisConnectionException (không kết nối được) và RedisTimeoutException (kết nối được nhưng quá hạn). Timeout thường do lệnh chậm hoặc thread pool cạn, không phải mạng.

Nguyên tắc thiết kế: cache là thành phần có thể mất, session và lock thì không. Với cache, bọc lời gọi trong try/catch và fallback về database; với session, Redis lỗi nghĩa là người dùng bị đăng xuất. Đừng để một timeout Redis làm sập luồng thanh toán chỉ vì bạn cache danh mục sản phẩm.

Distributed lock: đọc kỹ trước khi dùng

IDatabase.LockTakeAsync và LockReleaseAsync của StackExchange.Redis là implementation single-node: đủ giảm tranh chấp, không đủ đảm bảo loại trừ tuyệt đối khi node fail hoặc mạng phân vùng. Redlock với nhiều node độc lập vẫn là chủ đề tranh luận; nếu dữ liệu không thể sai, dùng Medallion.Threading hoặc RedLock.net, thêm fencing token, và đặt ràng buộc cuối ở database (unique index, row version). Không dùng lock Redis để bảo vệ bất biến tài chính.

2027: Redis và cache nhiều tầng

Hướng đi của .NET là cache nhiều tầng do framework quản lý: HybridCache với L1 trong process và L2 Redis. Redis 8 với search và vector sẽ xuất hiện nhiều hơn trong ứng dụng AI, nhưng vai trò cache vẫn là chính. Khi .NET 11 GA tháng 11/2026, API có thể đổi chi tiết, còn nguyên tắc — key tốt, TTL, invalidation rõ ràng — thì không.

Checklist

  1. Một IConnectionMultiplexer singleton với AbortOnConnectFail = false, ClientName và timeout rõ ràng.
  2. Tách instance hoặc database cho cache, session và lock; lock không nằm trong instance có thể evict.
  3. Mọi key có tiền tố ứng dụng, tenant và TTL; key không chứa dữ liệu cá nhân.
  4. Cache DTO, không cache entity; chọn JSON hoặc MessagePack có version.
  5. Dùng Lua cho compare-and-delete và rate limit; không dùng KEYS trên production.
  6. Đo hit ratio, evicted_keys, SLOWLOG; có fallback khi Redis timeout.

Đọc tiếp: Các chiến lược cache trong ASP.NET Core để chọn đúng mô hình; Cache in-memory vs cache phân tán để quyết định tầng lưu trữ; và Khóa phân tán trong ASP.NET Core để đi sâu vào giới hạn của lock Redis.