यह लेख Azure Redis Cache की मूल बातें और .NET Core Web API का उपयोग करके उनके कार्यान्वयन पर चर्चा करता है।
एजेंडा
- परिचय
- कैश क्या है?
- कैश के प्रकार
- Redis Cache
- Azure Redis Cache सेटअप
- चरण-दर-चरण कार्यान्वयन
पूर्वापेक्षाएँ
- Visual Studio 2022
- Azure खाता
- .NET Core 6
परिचय
कैशिंग आजकल सॉफ्टवेयर उद्योग में बहुत लोकप्रिय है क्योंकि यह एप्लिकेशन के प्रदर्शन और स्केलेबिलिटी में सुधार करता है। हम Gmail और Facebook जैसे कई वेब एप्लिकेशन का उपयोग करते हैं और देखते हैं कि वे कितने प्रतिक्रियाशील हैं और हमारे पास एक शानदार उपयोगकर्ता अनुभव है। इंटरनेट का उपयोग करने वाले बहुत सारे उपयोगकर्ता हैं और यदि किसी एप्लिकेशन में भारी नेटवर्क ट्रैफिक और मांग है, तो हमें कई चीजों का ध्यान रखना होगा जो एप्लिकेशन के प्रदर्शन और प्रतिक्रियाशीलता को बेहतर बनाने में मदद करती हैं। इसलिए, उसके कारण, कैशिंग का समाधान है और इसीलिए कैशिंग तस्वीर में आता है।
कैश क्या है?
कैश वह मेमोरी स्टोरेज है जिसका उपयोग बार-बार एक्सेस किए जाने वाले डेटा को अस्थायी भंडारण में स्टोर करने के लिए किया जाता है, यह प्रदर्शन को काफी हद तक सुधारता है और अनावश्यक डेटाबेस हिट से बचाता है और बार-बार उपयोग किए जाने वाले डेटा को कैश में स्टोर करता है।
जैसा कि आप ऊपर की छवि में देख सकते हैं, दो परिदृश्य हैं, एक कैश का उपयोग किए बिना और दूसरा कैश के साथ। तो यहां जब हम कैश का उपयोग नहीं करते हैं, उस मामले में, मान लीजिए उपयोगकर्ता डेटा चाहते हैं तो वे हर बार डेटाबेस को हिट करेंगे और यह समय जटिलता बढ़ाएगा और प्रदर्शन को कम करेगा यदि कुछ स्थिर डेटा है जो उपयोगकर्ता चाहते हैं और यह सभी उपयोगकर्ताओं के लिए समान है। जब हम कैश का उपयोग नहीं करते हैं, तो हर कोई डेटा लाने के लिए अनावश्यक रूप से डेटाबेस को हिट करता है। दूसरी तरफ, आप देख सकते हैं कि हम कैश का उपयोग करते हैं, और उस मामले में, यदि सभी उपयोगकर्ताओं के लिए समान स्थिर और समान डेटा है तो केवल पहला उपयोगकर्ता डेटाबेस को हिट करेगा और डेटा लाएगा और इसे कैश मेमोरी में स्टोर करेगा, और फिर अन्य दो उपयोगकर्ता डेटाबेस को अनावश्यक रूप से हिट किए बिना कैश से इसका उपयोग करेंगे।
कैश के प्रकार
मूल रूप से, .NET Core दो प्रकार के कैशिंग का समर्थन करता है
- इन-मेमोरी कैशिंग
- वितरित कैशिंग
जब हम इन-मेमोरी कैश का उपयोग करते हैं, तो डेटा एप्लिकेशन सर्वर मेमोरी में संग्रहीत होता है; जब भी हमें इसकी आवश्यकता होती है, हम उससे डेटा लाते हैं और जहां भी हमें इसकी आवश्यकता होती है इसका उपयोग करते हैं। और वितरित कैशिंग में Redis जैसे कई तृतीय-पक्ष तंत्र हैं। लेकिन इस खंड में, हम Redis Cache को विस्तार से देखते हैं और यह .NET Core में कैसे काम करता है
वितरित कैशिंग
- मूल रूप से, वितरित कैशिंग में डेटा कई सर्वरों के बीच संग्रहीत और साझा किया जाता है
- साथ ही, जब हम मल्टी-टेनेंट एप्लिकेशन का उपयोग करते हैं तो कई सर्वरों के बीच लोड प्रबंधित करके एप्लिकेशन की स्केलेबिलिटी और प्रदर्शन में सुधार करना आसान होता है
- मान लीजिए, भविष्य में, यदि एक सर्वर क्रैश हो जाता है और पुनः आरंभ होता है तो एप्लिकेशन पर कोई प्रभाव नहीं पड़ता क्योंकि कई सर्वर हमारी आवश्यकता के अनुसार होते हैं
Redis आजकल कई कंपनियों द्वारा एप्लिकेशन के प्रदर्शन और स्केलेबिलिटी को बेहतर बनाने के लिए उपयोग किया जाने वाला सबसे लोकप्रिय कैश है। तो, हम Redis और इसके उपयोग पर एक-एक करके चर्चा करने जा रहे हैं।
Redis Cache
- Redis एक ओपन सोर्स (BSD लाइसेंस्ड) इन-मेमोरी डेटा स्ट्रक्चर स्टोर है जिसे डेटाबेस के रूप में उपयोग किया जाता है।
- मूल रूप से, इसका उपयोग बार-बार उपयोग किए जाने वाले और कुछ स्थिर डेटा को कैश के अंदर स्टोर करने और उपयोगकर्ता की आवश्यकता के अनुसार उपयोग और आरक्षित करने के लिए किया जाता है।
- Redis में कई डेटा संरचनाएं मौजूद हैं जिनका उपयोग हम List, Set, Hashing, Stream, और कई अन्य जैसे डेटा स्टोर करने के लिए कर सकते हैं।
Azure Redis Cache सेटअप
चरण 1
Azure पोर्टल में लॉग इन करें।
चरण 2
मार्केटप्लेस में Azure Cache for Redis खोजें और इसे खोलें।
चरण 3
बनाएं पर क्लिक करें और अन्य जानकारी प्रदान करें।
चरण 4
उसके बाद, पहले बनाए गए कैश के अंदर एक्सेस कुंजी अनुभाग पर जाएं और प्राथमिक कनेक्शन स्ट्रिंग कॉपी करें जिसकी हमें .NET Core Web API के अंदर आवश्यकता है।
चरण-दर-चरण कार्यान्वयन
चरण 1
Visual Studio खोलें और एक नया .NET Core Web API प्रोजेक्ट बनाएं।
चरण 2
एक नया प्रोजेक्ट कॉन्फ़िगर करें।
चरण 3
अतिरिक्त विवरण प्रदान करें।
चरण 4
प्रोजेक्ट संरचना।
चरण 5
उत्पाद विवरण क्लास बनाएं।
namespace AzureRedisCacheDemo.Models
{
public class ProductDetails
{
public int Id { get; set; }
public string ProductName { get; set; }
public string ProductDescription { get; set; }
public int ProductPrice { get; set; }
public int ProductStock { get; set; }
}
}चरण 6
अगला, Data फोल्डर के अंदर Db Context Class जोड़ें।
using AzureRedisCacheDemo.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
namespace AzureRedisCacheDemo.Data
{
public class DbContextClass: DbContext
{
public DbContextClass(DbContextOptions < DbContextClass > options): base(options) {}
public DbSet < ProductDetails > Products { get; set; }
}
}चरण 7
उसके बाद, Seed Data क्लास जोड़ें जिसका उपयोग हम प्रारंभ में कुछ डेटा डालने के लिए करते हैं।
using AzureRedisCacheDemo.Models;
using Microsoft.EntityFrameworkCore;
namespace AzureRedisCacheDemo.Data
{
public class SeedData
{
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new DbContextClass(
serviceProvider.GetRequiredService<DbContextOptions<DbContextClass>>()))
{
if (context.Products.Any())
{
return;
}
context.Products.AddRange(
new ProductDetails
{
Id = 1,
ProductName = "IPhone",
ProductDescription = "IPhone 14",
ProductPrice = 120000,
ProductStock = 100
},
new ProductDetails
{
Id = 2,
ProductName = "Samsung TV",
ProductDescription = "Smart TV",
ProductPrice = 400000,
ProductStock = 120
});
context.SaveChanges();
}
}
}
}चरण 8
appsettings.json फाइल के अंदर Azure Redis Cache कनेक्शन स्ट्रिंग कॉन्फ़िगर करें।
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"RedisURL": "<valuefromportal>"
}चरण 9
Configuration Manager और Connection Helper क्लास Helper फोल्डर के अंदर बनाएं जिनका उपयोग हम कनेक्शन उद्देश्यों के लिए करते हैं।
Configuration Manager
namespace AzureRedisCacheDemo.Helper
{
static class ConfigurationManager
{
public static IConfiguration AppSetting { get; }
static ConfigurationManager()
{
AppSetting = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json").Build();
}
}
}Connection Helper
using StackExchange.Redis;
namespace AzureRedisCacheDemo.Helper
{
public class ConnectionHelper
{
static ConnectionHelper()
{
ConnectionHelper.lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
{
return ConnectionMultiplexer.Connect(ConfigurationManager.AppSetting["RedisURL"]);
});
}
private static Lazy<ConnectionMultiplexer> lazyConnection;
public static ConnectionMultiplexer Connection
{
get { return lazyConnection.Value; }
}
}
}चरण 10
अगला, Repositories के अंदर IProductService जोड़ें।
using AzureRedisCacheDemo.Models;
namespace AzureRedisCacheDemo.Repositories
{
public interface IProductService
{
public Task<List<ProductDetails>> ProductListAsync();
public Task<ProductDetails> GetProductDetailByIdAsync(int productId);
public Task<bool> AddProductAsync(ProductDetails productDetails);
public Task<bool> UpdateProductAsync(ProductDetails productDetails);
public Task<bool> DeleteProductAsync(int productId);
}
}चरण 11
अगला, ProductService क्लास बनाएं और उसमें IProductService इंटरफेस लागू करें।
using AzureRedisCacheDemo.Data;
using AzureRedisCacheDemo.Models;
using Microsoft.EntityFrameworkCore;
using System.Linq;
namespace AzureRedisCacheDemo.Repositories
{
public class ProductService: IProductService
{
private readonly DbContextClass dbContextClass;
public ProductService(DbContextClass dbContextClass)
{
this.dbContextClass = dbContextClass;
}
public async Task<List<ProductDetails>> ProductListAsync()
{
return await dbContextClass.Products.ToListAsync();
}
public async Task<ProductDetails> GetProductDetailByIdAsync(int productId)
{
return await dbContextClass.Products.Where(ele => ele.Id == productId).FirstOrDefaultAsync();
}
public async Task<bool> AddProductAsync(ProductDetails productDetails)
{
await dbContextClass.Products.AddAsync(productDetails);
var result = await dbContextClass.SaveChangesAsync();
if (result > 0) { return true; } else { return false; }
}
public async Task<bool> UpdateProductAsync(ProductDetails productDetails)
{
var isProduct = ProductDetailsExists(productDetails.Id);
if (isProduct)
{
dbContextClass.Products.Update(productDetails);
var result = await dbContextClass.SaveChangesAsync();
if (result > 0) { return true; } else { return false; }
}
return false;
}
public async Task<bool> DeleteProductAsync(int productId)
{
var findProductData = dbContextClass.Products.Where(_ => _.Id == productId).FirstOrDefault();
if (findProductData != null)
{
dbContextClass.Products.Remove(findProductData);
var result = await dbContextClass.SaveChangesAsync();
if (result > 0) { return true; } else { return false; }
}
return false;
}
private bool ProductDetailsExists(int productId)
{
return dbContextClass.Products.Any(e => e.Id == productId);
}
}
}चरण 12
एक IRedisCache इंटरफेस बनाएं।
namespace AzureRedisCacheDemo.Repositories.AzureRedisCache
{
public interface IRedisCache
{
T GetCacheData<T>(string key);
bool SetCacheData<T>(string key, T value, DateTimeOffset expirationTime);
object RemoveData(string key);
}
}चरण 13
उसके बाद, RedisCache क्लास बनाएं और उसमें पहले बनाए गए इंटरफेस मेथड लागू करें।
using AzureRedisCacheDemo.Helper;
using Newtonsoft.Json;
using StackExchange.Redis;
namespace AzureRedisCacheDemo.Repositories.AzureRedisCache
{
public class RedisCache : IRedisCache
{
private IDatabase _db;
public RedisCache()
{
ConfigureRedis();
}
private void ConfigureRedis()
{
_db = ConnectionHelper.Connection.GetDatabase();
}
public T GetCacheData<T>(string key)
{
var value = _db.StringGet(key);
if (!string.IsNullOrEmpty(value))
{
return JsonConvert.DeserializeObject<T>(value);
}
return default;
}
public object RemoveData(string key)
{
bool _isKeyExist = _db.KeyExists(key);
if (_isKeyExist == true)
{
return _db.KeyDelete(key);
}
return false;
}
public bool SetCacheData<T>(string key, T value, DateTimeOffset expirationTime)
{
TimeSpan expiryTime = expirationTime.DateTime.Subtract(DateTime.Now);
var isSet = _db.StringSet(key, JsonConvert.SerializeObject(value), expiryTime);
return isSet;
}
}
}चरण 14
एक नया Products Controller बनाएं।
using AzureRedisCacheDemo.Models;
using AzureRedisCacheDemo.Repositories;
using AzureRedisCacheDemo.Repositories.AzureRedisCache;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
namespace AzureRedisCacheDemo.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class ProductsController : ControllerBase
{
private readonly IProductService _productService;
private readonly IRedisCache _redisCache;
public ProductsController(IProductService productService, IRedisCache redisCache)
{
_productService = productService;
_redisCache = redisCache;
}
[HttpGet]
public async Task<ActionResult<List<ProductDetails>>> ProductListAsync()
{
var cacheData = _redisCache.GetCacheData<List<ProductDetails>>("product");
if (cacheData != null)
{
return new List<ProductDetails>(cacheData);
}
var productList = await _productService.ProductListAsync();
if(productList != null)
{
var expirationTime = DateTimeOffset.Now.AddMinutes(5.0);
_redisCache.SetCacheData<List<ProductDetails>>("product", productList, expirationTime);
return Ok(productList);
}
else { return NoContent(); }
}
[HttpGet("{productId}")]
public async Task<ActionResult<ProductDetails>> GetProductDetailsByIdAsync(int productId)
{
var cacheData = _redisCache.GetCacheData<List<ProductDetails>>("product");
if (cacheData != null)
{
ProductDetails filteredData = cacheData.Where(x => x.Id == productId).FirstOrDefault();
return new ActionResult<ProductDetails>(filteredData);
}
var productDetails = await _productService.GetProductDetailByIdAsync(productId);
if(productDetails != null) { return Ok(productDetails); }
else { return NotFound(); }
}
[HttpPost]
public async Task<IActionResult> AddProductAsync(ProductDetails productDetails)
{
var isProductInserted = await _productService.AddProductAsync(productDetails);
_redisCache.RemoveData("product");
if (isProductInserted) { return Ok(isProductInserted); }
else { return BadRequest(); }
}
[HttpPut]
public async Task<IActionResult> UpdateProductAsync(ProductDetails productDetails)
{
var isProductUpdated = await _productService.UpdateProductAsync(productDetails);
_redisCache.RemoveData("product");
if (isProductUpdated) { return Ok(isProductUpdated); }
else { return BadRequest(); }
}
[HttpDelete]
public async Task<IActionResult> DeleteProductAsync(int productId)
{
var isProductDeleted = await _productService.DeleteProductAsync(productId);
_redisCache.RemoveData("product");
if (isProductDeleted) { return Ok(isProductDeleted); }
else { return BadRequest(); }
}
}
}चरण 15
Program क्लास के अंदर कुछ सेवाएं पंजीकृत करें।
using AzureRedisCacheDemo.Data;
using AzureRedisCacheDemo.Models;
using AzureRedisCacheDemo.Repositories;
using AzureRedisCacheDemo.Repositories.AzureRedisCache;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
using System;
var builder = WebApplication.CreateBuilder(args);
// कंटेनर में सेवाएं जोड़ें
builder.Services.AddScoped<IProductService, ProductService>();
builder.Services.AddDbContext<DbContextClass>(o => o.UseInMemoryDatabase("RedisCacheDemo"));
builder.Services.AddScoped<IRedisCache, RedisCache>();
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
using(var scope = app.Services.CreateScope())
{
var services = scope.ServiceProvider;
var context = services.GetRequiredService<DbContextClass>();
SeedData.Initialize(services);
}
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();चरण 16
अंत में, एप्लिकेशन चलाएं और हम अपने API के एंडपॉइंट्स के साथ Swagger UI देख सकते हैं।
चरण 17
उत्पाद प्राप्त करने वाले एंडपॉइंट को हिट करें और Azure Portal के अंदर Redis CLI खोलें और वहां आप देख सकते हैं कि उत्पाद सूची पहली बार एंडपॉइंट हिट करने पर स्टोर हो जाएगी।
इस मामले में, पहले, हम जांचते हैं कि डेटा कैश में मौजूद है या नहीं। यदि नहीं तो हम डेटाबेस से डेटा प्राप्त करते हैं और इसे कैश में भी सहेजते हैं। हमने पहले से ही कंट्रोलर के अंदर इससे संबंधित कोड लिखा है। तो, अगली बार हमें डेटा कैश से मिलता है। यदि आप कंट्रोलर के अंदर एक डिबगर डालते हैं तो आप आसानी से समझ सकते हैं कि चीजें कैसे काम करने जा रही हैं।
GitHub URL
https://github.com/Jaydeep-007/AzureRedisCacheDemo/tree/master/AzureRedisCacheDemo
निष्कर्ष
यहां हमने कैश परिचय और Azure पर उनके कॉन्फ़िगरेशन को देखा। साथ ही, .NET Core Web API का उपयोग करके चरण-दर-चरण कार्यान्वयन।
