A resilient Redis client for Azure Cache for Redis with Managed Identity support, Service Bus event publishing, and automatic fallback patterns. Includes retry policies, circuit breaker, and comprehensive logging.
public class UserService
{
private readonly IResilientRedisClient _redisClient;
public UserService(IResilientRedisClient redisClient)
{
_redisClient = redisClient;
}
public async Task<User?> GetUserAsync(int userId)
{
var key = $"user:{userId}";
// Obtener con fallback automático
var result = await _redisClient.GetOrCreateAsync(key, async () =>
{
// Este método se ejecuta solo si no está en cache
return await _userRepository.GetByIdAsync(userId);
}, TimeSpan.FromMinutes(30));
return result.Value;
}
}
Patrones de Fallback
🔄 Patrón 1: Fallback a Base de Datos
public class ProductService
{
private readonly IResilientRedisClient _redisClient;
private readonly IProductRepository _repository;
public async Task<Product?> GetProductAsync(int productId)
{
var key = $"product:{productId}";
var result = await _redisClient.GetOrCreateAsync(key, async () =>
{
// Fallback: obtener de base de datos
var product = await _repository.GetByIdAsync(productId);
return product;
}, TimeSpan.FromHours(1));
return result.Value;
}
}
🔄 Patrón 2: Fallback a Microservicio Externo
public class InventoryService
{
private readonly IResilientRedisClient _redisClient;
private readonly HttpClient _httpClient;
public async Task<InventoryItem?> GetInventoryAsync(string sku)
{
var key = $"inventory:{sku}";
var result = await _redisClient.GetOrCreateAsync(key, async () =>
{
// Fallback: llamar a microservicio de inventario
var response = await _httpClient.GetAsync($"/api/inventory/{sku}");
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
return JsonSerializer.Deserialize<InventoryItem>(json);
}
return null;
}, TimeSpan.FromMinutes(15));
return result.Value;
}
}
🔄 Patrón 3: Microservicio Responsable de Cache
Cuando otro microservicio es responsable de poblar el cache:
public class OrderService
{
private readonly IResilientRedisClient _redisClient;
private readonly IOrderProcessingService _orderProcessor;
public async Task<Order?> GetOrderAsync(int orderId)
{
var key = $"order:{orderId}";
// Intentar obtener del cache
var cachedResult = await _redisClient.GetAsync<Order>(key);
if (cachedResult.Success && cachedResult.Value != null)
{
return cachedResult.Value;
}
// Si no está en cache, solicitar al microservicio responsable
await _orderProcessor.RequestOrderCachingAsync(orderId);
// Esperar un momento y reintentar
await Task.Delay(TimeSpan.FromMilliseconds(500));
var retryResult = await _redisClient.GetAsync<Order>(key);
return retryResult.Value;
}
}
// Microservicio responsable del cache
public class OrderProcessingService : IOrderProcessingService
{
private readonly IResilientRedisClient _redisClient;
private readonly IOrderRepository _repository;
public async Task RequestOrderCachingAsync(int orderId)
{
// Obtener datos y cachear
var order = await _repository.GetOrderWithDetailsAsync(orderId);
if (order != null)
{
var key = $"order:{orderId}";
await _redisClient.SetAsync(key, order, TimeSpan.FromHours(2));
}
}
}
🔄 Patrón 4: Cache-Aside con Notificación
public class CatalogService
{
private readonly IResilientRedisClient _redisClient;
private readonly ICatalogRepository _repository;
private readonly IServiceBus _serviceBus;
public async Task<Product?> GetProductAsync(int productId)
{
var key = $"product:{productId}";
var result = await _redisClient.GetAsync<Product>(key);
if (!result.Success || result.Value == null)
{
// Notificar que se necesita el producto en cache
await _serviceBus.PublishAsync(new ProductCacheRequest
{
ProductId = productId,
RequestedBy = "CatalogService",
Timestamp = DateTime.UtcNow
});
// Obtener directamente de la base de datos como fallback
return await _repository.GetByIdAsync(productId);
}
return result.Value;
}
}
Configuración de Managed Identity
En Azure App Service
Habilita System Assigned Identity en tu App Service
Asigna los roles necesarios:
Redis: "Redis Cache Contributor"
Service Bus: "Azure Service Bus Data Sender"
En desarrollo local
az login
# El cliente usará automáticamente tus credenciales de Azure CLI
Monitoreo y Eventos
Si tienes Service Bus habilitado, puedes monitorear eventos:
public class RedisEventHandler
{
public async Task HandleRedisEvent(RedisEvent redisEvent)
{
switch (redisEvent.EventType)
{
case RedisEventType.CacheMiss:
// Lógica para cache miss
_metrics.IncrementCounter("redis.cache_miss");
break;
case RedisEventType.FallbackTriggered:
// Lógica para cuando se usa fallback
_metrics.IncrementCounter("redis.fallback_used");
break;
case RedisEventType.Error:
// Lógica para errores
_logger.LogError("Redis error: {Message}", redisEvent.ErrorMessage);
break;
}
}
}
Mejores Prácticas
🎯 Para Configuración
Usa configuración básica si solo necesitas Redis
Habilita Service Bus solo si necesitas monitoreo de eventos
Configura Managed Identity en producción para mayor seguridad
🎯 Para Fallback
Implementa timeouts apropiados en servicios de fallback
Considera el impacto en rendimiento de llamadas externas
Usa circuit breakers para servicios externos inestables
🎯 Para Microservicios
Define claramente qué servicio es responsable de cada cache
Implementa patrones de notificación para cache warming
Usa TTL apropiados según la frecuencia de cambio de datos
Troubleshooting
Problemas de Conexión
Verifica connection strings o configuración de Managed Identity
Confirma que los roles de Azure estén asignados correctamente
Revisa los logs para errores de autenticación
Problemas de Rendimiento
Ajusta los valores de timeout y retry
Monitorea las métricas de Service Bus (si está habilitado)
Considera usar connection pooling
Ejemplos Completos
Ver la carpeta examples/ para implementaciones completas de diferentes patrones.