Redis چیست و چرا باید از آن استفاده کنیم؟

Redis که مخفف REmote DIctionary Server است، یک پایگاه داده NoSQL از نوع کلید-مقدار (Key-Value) و درون-حافظه‌ای (In-Memory) است. "درون-حافظه‌ای" بودن به این معناست که Redis داده‌ها را به جای دیسک سخت (HDD/SSD)، مستقیماً در حافظه اصلی (RAM) سرور ذخیره می‌کند. این ویژگی باعث می‌شود سرعت خواندن و نوشتن داده‌ها در Redis به شدت بالا باشد و آن را به یک گزینه ایده‌آل برای مکانیزم‌های کشینگ تبدیل کند.

مزایای کلیدی استفاده از Redis:

• سرعت فوق‌العاده بالا: به دلیل ذخیره‌سازی داده‌ها در RAM، عملیات خواندن و نوشتن با تأخیر بسیار پایینی (در حد میکروثانیه) انجام می‌شود. این سرعت بالا به طور مستقیم به کاهش زمان پاسخ‌دهی برنامه شما منجر می‌شود.

• پشتیبانی از ساختارهای داده متنوع: Redis تنها یک ذخیره‌گاه ساده کلید-مقدار نیست. این ابزار از ساختارهای داده‌ای غنی مانند رشته‌ها (Strings)، لیست‌ها (Lists)، مجموعه‌ها (Sets)، هش‌ها (Hashes) و مجموعه‌های مرتب (Sorted Sets) پشتیبانی می‌کند که انعطاف‌پذیری بالایی برای ذخیره‌سازی انواع مختلف داده فراهم می‌کند.

• کش توزیع‌شده (Distributed Caching): در معماری‌های مدرن که برنامه روی چندین سرور (Load Balancing) اجرا می‌شود، استفاده از کش محلی (In-Memory Cache) هر سرور بی‌فایده است. Redis به عنوان یک سرور کش مرکزی عمل می‌کند که تمام نمونه‌های برنامه می‌توانند به آن متصل شده و داده‌های کش شده را به اشتراک بگذارند.

• پایداری داده‌ها (Persistence): اگرچه Redis یک پایگاه داده درون-حافظه‌ای است، اما این قابلیت را دارد که در فواصل زمانی معین یا پس از تعداد مشخصی از تغییرات، یک نسخه از داده‌ها را روی دیسک ذخیره کند. این ویژگی تضمین می‌کند که در صورت ری‌استارت شدن سرور Redis، داده‌ها از بین نروند.

• کاربردهای متنوع: علاوه بر کشینگ، از Redis می‌توان برای مدیریت نشست‌های کاربران (Session Management)، پیاده‌سازی صف‌های پیام (Message Queues) و ارتباطات آنی (Real-time Communication) از طریق مکانیزم Pub/Sub نیز استفاده کرد.

راه‌اندازی و پیکربندی Redis در پروژه ASP.NET Core

برای شروع کار با Redis در یک پروژه ASP.NET Core، ابتدا باید Redis را نصب و سپس پروژه خود را برای اتصال به آن پیکربندی کنید.

گام اول: نصب و اجرای Redis

ساده‌ترین و محبوب‌ترین روش برای راه‌اندازی Redis در محیط توسعه، استفاده از Docker است. با اجرای یک دستور ساده در ترمینال، می‌توانید یک کانتینر Redis راه‌اندازی کنید:

docker run --name my-redis-container -p 6379:6379 -d redis

این دستور یک کانتینر داکر به نام my-redis-container را اجرا می‌کند و پورت پیش‌فرض Redis یعنی 6379 را به همین پورت روی ماشین میزبان شما متصل می‌سازد.

گام دوم: افزودن پکیج‌های NuGet

در مرحله بعد، باید پکیج NuGet مربوط به Redis را به پروژه ASP.NET Core خود اضافه کنید. مایکروسافت یک پکیج استاندارد برای کار با کش توزیع‌شده مبتنی بر Redis فراهم کرده است. این پکیج را از طریق Package Manager Console یا دستور dotnet CLI نصب کنید:

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

این پکیج از کتابخانه محبوب StackExchange.Redis برای برقراری ارتباط با سرور Redis استفاده می‌کند.

گام سوم: پیکربندی سرویس Redis Cache

پس از نصب پکیج، باید سرویس کش توزیع‌شده Redis را در فایل Program.cs (یا Startup.cs در نسخه‌های قدیمی‌تر) برنامه خود ثبت و پیکربندی کنید.

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

// --- پیکربندی Redis ---
builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
    options.InstanceName = "SampleInstance_"; // یک پیشوند برای کلیدهای کش
});

var app = builder.Build();

در کد بالا، ما سرویس AddStackExchangeRedisCache را اضافه کرده‌ایم. options.Configuration رشته اتصال به سرور Redis را مشخص می‌کند. بهتر است این رشته اتصال را در فایل appsettings.json مدیریت کنید:

{
  "ConnectionStrings": {
    "Redis": "localhost:6379"
  },
  // ... سایر تنظیمات
}

پیاده‌سازی کشینگ داده با الگوی Cache-Aside

یکی از رایج‌ترین الگوها برای کار با کش، الگوی Cache-Aside (یا Lazy Loading) است. در این الگو، منطق برنامه به این صورت عمل می‌کند:

1. ابتدا برای دریافت داده، به کش (Redis) مراجعه می‌کند.

2. اگر داده در کش موجود بود (Cache Hit)، آن را از کش خوانده و بازمی‌گرداند.

3. اگر داده در کش موجود نبود (Cache Miss)، به پایگاه داده اصلی مراجعه کرده و داده را می‌خواند.

4. سپس داده خوانده شده از پایگاه داده را در کش ذخیره می‌کند تا در درخواست‌های بعدی قابل استفاده باشد.

5. در نهایت، داده را به کاربر بازمی‌گرداند.

مثال عملی: کش کردن لیست محصولات

فرض کنید یک متد در سرویس خود دارید که لیستی از محصولات را از پایگاه داده دریافت می‌کند. با استفاده از اینترفیس IDistributedCache که در ASP.NET Core تعبیه شده، می‌توانیم این عملیات را کش کنیم.

ابتدا اینترفیس IDistributedCache را به سرویس یا کنترلر مورد نظر خود تزریق (Inject) کنید:

public class ProductController : ControllerBase
{
    private readonly IProductService _productService;
    private readonly IDistributedCache _cache;

    public ProductController(IProductService productService, IDistributedCache cache)
    {
        _productService = productService;
        _cache = cache;
    }
}

حالا متد دریافت محصولات را به صورت زیر پیاده‌سازی می‌کنیم:

[HttpGet]
public async Task<IActionResult> GetProducts()
{
    const string cacheKey = "ListOfProducts";
    string serializedProducts;
    List<Product> products;

    var cachedProducts = await _cache.GetStringAsync(cacheKey);

    if (cachedProducts != null)
    {
        // داده در کش موجود است (Cache Hit)
        serializedProducts = cachedProducts;
        products = JsonSerializer.Deserialize<List<Product>>(serializedProducts);
    }
    else
    {
        // داده در کش موجود نیست (Cache Miss)
        products = await _productService.GetAllProductsAsync();
        serializedProducts = JsonSerializer.Serialize(products);

        // تنظیمات انقضای کش (مثلاً ۵ دقیقه)
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromMinutes(5))
            .SetAbsoluteExpiration(TimeSpan.FromHours(1));

        await _cache.SetStringAsync(cacheKey, serializedProducts, options);
    }

    return Ok(products);
}

در این مثال، ابتدا با استفاده از _cache.GetStringAsync(cacheKey) وجود داده در کش را بررسی می‌کنیم. اگر داده موجود نبود، آن را از سرویس محصولات گرفته، به فرمت JSON سریالایز کرده و با استفاده از _cache.SetStringAsync() در Redis ذخیره می‌کنیم. همچنین با استفاده از DistributedCacheEntryOptions می‌توانیم زمان انقضای کش را تعیین کنیم تا داده‌ها برای همیشه در حافظه باقی نمانند و پس از مدتی به‌روز شوند.

استفاده از Redis برای مدیریت نشست (Session Management)

یکی دیگر از کاربردهای فوق‌العاده Redis در برنامه‌های ASP.NET Core، مدیریت وضعیت نشست (Session State) کاربران است. به طور پیش‌فرض، ASP.NET Core نشست‌ها را در حافظه سرور برنامه ذخیره می‌کند که در محیط‌های چند سروری (Web Farm/Cloud) مشکل‌ساز است. اگر درخواست‌های یک کاربر به سرورهای مختلفی ارسال شود، اطلاعات نشست او از بین می‌رود.

با ذخیره کردن اطلاعات نشست در Redis، تمام سرورها به یک منبع مشترک برای داده‌های نشست دسترسی خواهند داشت و این مشکل حل می‌شود.

پیکربندی Session با Redis

برای این کار، ابتدا پکیج مربوطه را نصب کنید (معمولاً همراه با پکیج اصلی نصب می‌شود). سپس در Program.cs، سرویس‌های مربوط به Session و Redis را به صورت زیر پیکربندی کنید:

var builder = WebApplication.CreateBuilder(args);

// ... سایر سرویس‌ها

// پیکربندی Redis
builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
    options.InstanceName = "SessionInstance_";
});

// پیکربندی Session برای استفاده از Redis
builder.Services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromMinutes(30); // زمان منقضی شدن نشست
    options.Cookie.HttpOnly = true;
    options.Cookie.IsEssential = true;
});

var app = builder.Build();

// ... سایر middleware ها

app.UseSession(); // فعال‌سازی middleware مربوط به Session

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

با این پیکربندی ساده، ASP.NET Core به طور خودکار تمام داده‌های نشست را به جای حافظه محلی، در سرور Redis شما ذخیره خواهد کرد. اکنون می‌توانید مانند گذشته از HttpContext.Session برای خواندن و نوشتن داده در نشست استفاده کنید و نگران از دست رفتن اطلاعات در محیط‌های توزیع‌شده نباشید.

نکات و بهترین شیوه‌ها (Best Practices)

• سریالایز کردن داده‌ها: Redis داده‌ها را به صورت بایت (byte array) ذخیره می‌کند. قبل از ذخیره کردن اشیاء پیچیده، آن‌ها را به یک فرمت بهینه مانند JSON یا MessagePack سریالایز کنید.

• مدیریت کلیدهای کش: برای کلیدهای خود یک الگوی نام‌گذاری مشخص و معنادار تعریف کنید تا از تداخل جلوگیری کرده و مدیریت آن‌ها را آسان‌تر سازید. استفاده از پیشوند (مانند InstanceName در پیکربندی) یک روش خوب است.

• استراتژی انقضای کش: همیشه برای داده‌های کش خود یک زمان انقضا (Expiration) تعیین کنید. این کار از قدیمی شدن داده‌ها (Stale Data) جلوگیری کرده و حافظه Redis را بهینه مصرف می‌کند.

• کش کردن داده‌های مناسب: همه داده‌ها برای کش شدن مناسب نیستند. داده‌هایی که به ندرت تغییر می‌کنند و به دفعات زیاد خوانده می‌شوند (مانند لیست دسته‌بندی‌ها، اطلاعات محصولات) بهترین کاندیداها برای کشینگ هستند.

• مدیریت Cache Invalidation: یکی از چالش‌های کار با کش، بی‌اعتبار کردن یا حذف داده‌های کش شده در زمان مناسب است. برای مثال، زمانی که اطلاعات یک محصول ویرایش می‌شود، باید نسخه کش شده آن را از Redis حذف کنید تا در درخواست بعدی، اطلاعات جدید از پایگاه داده خوانده و کش شود.

نتیجه‌گیری

Redis یک ابزار قدرتمند و انعطاف‌پذیر است که می‌تواند به طور چشمگیری عملکرد، مقیاس‌پذیری و پاسخگویی برنامه‌های ASP.NET Core را بهبود بخشد. با پیاده‌سازی صحیح استراتژی‌های کشینگ داده و استفاده از آن برای مدیریت نشست‌های توزیع‌شده، می‌توانید فشار را از روی پایگاه داده خود برداشته، زمان پاسخ‌دهی را کاهش دهید و تجربه کاربری بهتری را برای کاربران خود رقم بزنید. ادغام Redis با ASP.NET Core از طریق اینترفیس IDistributedCache بسیار ساده و استاندارد است و به توسعه‌دهندگان اجازه می‌دهد با کمترین تغییر در کد، از مزایای یک کش درون-حافظه‌ای، سریع و توزیع‌شده بهره‌مند شوند.