feat: integrate Redis caching for improved performance and content management

Author: csharpfritz

AppHost/AppHost.cs

@@ -5,23 +5,31 @@
 
 var builder = DistributedApplication.CreateBuilder(args);
 
+// Add Redis cache
+var redis = builder.AddRedis("redis")
+		.WithRedisInsight()
+		.WithLifetime(ContainerLifetime.Persistent)
+		.PublishAsConnectionString();
+
 // NOTE: The type returned by AddAzureStorage is IResourceBuilder<AzureStorageResource>,
 // but if storage is being cast or wrapped, ensure it is of the correct type for extension methods.
 var storage = builder.AddAzureStorage("azure-storage")
-	.RunAsEmulator(options =>
-	{
-		// Configure the Azure Storage Emulator options here if needed
-		options.WithLifetime(ContainerLifetime.Persistent);
-		options.WithTablePort(27002);
-		options.WithBlobPort(27001);
-		options.WithQueuePort(27003);
-	});
+    .RunAsEmulator(options =>
+    {
+        // Configure the Azure Storage Emulator options here if needed
+        options.WithLifetime(ContainerLifetime.Persistent);
+        options.WithTablePort(27002);
+        options.WithBlobPort(27001);
+        options.WithQueuePort(27003);
+    });
 
 var tables = storage.AddTables("tables");
 
 var web = builder.AddProject<Web>("web")
-	.WithReference(tables)
-	.WaitFor(tables)
-	.WithExternalHttpEndpoints();
+    .WithReference(tables)
+    .WithReference(redis)
+    .WaitFor(tables)
+    .WaitFor(redis)
+    .WithExternalHttpEndpoints();
 
 builder.Build().Run();

AppHost/AppHost.csproj

@@ -9,11 +9,11 @@
     <Nullable>enable</Nullable>
     <UserSecretsId>21fabb30-ac7d-4818-8766-92672e7b369a</UserSecretsId>
   </PropertyGroup>
-
   <ItemGroup>
     <PackageReference Include="Aspire.Hosting.AppHost" Version="9.3.0" />
     <PackageReference Include="Aspire.Hosting.Azure.AppContainers" Version="9.3.0" />
     <PackageReference Include="Aspire.Hosting.Azure.Storage" Version="9.3.0" />
+    <PackageReference Include="Aspire.Hosting.Redis" Version="9.3.0" />
   </ItemGroup>
 
   <ItemGroup>

AppHost/infra/web.tmpl.yaml

@@ -17,21 +17,14 @@ properties:
       targetPort: {{ targetPortOrDefault 8080 }}
       transport: http
       allowInsecure: false
-      customDomains:
-        - name: copilotthatjawn.com
-          bindingType: SniEnabled
-          certificateId: /subscriptions/09153f92-3cbc-46f1-8872-1683749eda4b/resourceGroups/rg-copilotthatjawn/providers/Microsoft.App/managedEnvironments/cae-uanpydy4xv63a/managedCertificates/copilotthatjawn.com-cae-uanp-250608192822
-        - name: www.copilotthatjawn.com
-          bindingType: SniEnabled
-          certificateId: /subscriptions/09153f92-3cbc-46f1-8872-1683749eda4b/resourceGroups/rg-copilotthatjawn/providers/Microsoft.App/managedEnvironments/cae-uanpydy4xv63a/managedCertificates/www.copilotthatjawn.com-cae-uanp-250608193349
     registries:
       - server: {{ .Env.AZURE_CONTAINER_REGISTRY_ENDPOINT }}
         identity: {{ .Env.AZURE_CONTAINER_REGISTRY_MANAGED_IDENTITY_ID }}
     secrets:
+      - name: connectionstrings--redis
+        value: '{{ securedParameter "redis" }}'
       - name: connectionstrings--tables
         value: '{{ .Env.AZURE_STORAGE_TABLEENDPOINT }}'
-      - name: cacherefresh--apikey
-        value: '{{ .Env.CACHE_REFRESH_API_KEY }}'
   template:
     containers:
       - image: {{ .Image }}
@@ -49,10 +42,10 @@ properties:
             value: "true"
           - name: OTEL_DOTNET_EXPERIMENTAL_OTLP_RETRY
             value: in_memory
+          - name: ConnectionStrings__redis
+            secretRef: connectionstrings--redis
           - name: ConnectionStrings__tables
             secretRef: connectionstrings--tables
-          - name: CacheRefresh__ApiKey
-            secretRef: cacherefresh--apikey
     scale:
       minReplicas: 1
 tags:

Web/Pages/Tips/Details.cshtml.cs

@@ -1,17 +1,18 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.RazorPages;
+using Microsoft.AspNetCore.OutputCaching;
 using Shared;
 using Web.Services;
 
 namespace Web.Pages.Tips;
 
+[OutputCache(PolicyName = "TipsContent")]
 public class DetailsModel : BasePageModel
 {
     private readonly IContentService _contentService;
     private readonly ILogger<DetailsModel> _logger;
-    
-    // Override cache duration for individual tips - cache for 1 hour since they change less frequently
-    protected override int CacheDurationSeconds => 3600;
+      // Override cache duration for individual tips - cache for 24 hours since tips are relatively static content
+    protected override int CacheDurationSeconds => 86400; // 24 hours
 
     public DetailsModel(IContentService contentService, ILogger<DetailsModel> logger)
     {

Web/Pages/Tips/Index.cshtml.cs

@@ -9,9 +9,8 @@ public class IndexModel : BasePageModel
 {
     private readonly IContentService _contentService;
     private readonly ILogger<IndexModel> _logger;
-    
-    // Override cache duration for tips list - cache for 5 minutes
-    protected override int CacheDurationSeconds => 300;
+      // Override cache duration for tips list - cache for 1 hour since new tips are added infrequently
+    protected override int CacheDurationSeconds => 3600; // 1 hour
 
     public IndexModel(IContentService contentService, ILogger<IndexModel> logger)
     {

Web/Program.cs

@@ -14,6 +14,17 @@
 
 builder.AddAzureTableClient("tables");
 
+// Add Redis distributed caching - manual configuration since extension doesn't exist
+
+builder.AddRedisDistributedCache("redis");
+builder.AddRedisOutputCache("redis");
+
+// Configure Redis key prefixes for better organization
+builder.Services.PostConfigure<Microsoft.Extensions.Caching.StackExchangeRedis.RedisCacheOptions>(options =>
+{
+    options.InstanceName = "CopilotThatJawn:";
+});
+
 // Add WebOptimizer services
 builder.Services.AddWebOptimizer(pipeline =>
 {
@@ -57,28 +68,40 @@
 // Add caching services
 builder.Services.AddResponseCaching();
 builder.Services.AddMemoryCache();
-builder.Services.AddOutputCache(options =>
+
+// Configure output cache policies (Redis is already configured above via AddRedisOutputCache)
+builder.Services.Configure<Microsoft.AspNetCore.OutputCaching.OutputCacheOptions>(options =>
 {
     // Default site-wide caching policy
     options.AddBasePolicy(builder => 
         builder.Cache()
                .SetVaryByHost(true)
                .SetVaryByQuery("*")
                .SetVaryByHeader("Accept-Language")  // Vary by language
-               .Expire(TimeSpan.FromMinutes(10))); // Cache for 10 minutes by default
-               
-    // Special policy for static content pages
+               .Expire(TimeSpan.FromMinutes(10))    // Cache for 10 minutes by default
+               .Tag("outputcache", "site")); // Add tags for better organization
+                 // Special policy for static content pages
     options.AddPolicy("StaticContent", builder => 
         builder.Cache()
                .SetVaryByHost(true)
-               .Expire(TimeSpan.FromHours(1))); // Cache static content for 1 hour
+               .Expire(TimeSpan.FromHours(1))       // Cache static content for 1 hour
+               .Tag("outputcache", "static")); // Add tags for better organization
+               
+    // Special policy for tips and content pages - cache for 24 hours since they're relatively static
+    options.AddPolicy("TipsContent", builder => 
+        builder.Cache()
+               .SetVaryByHost(true)
+               .SetVaryByRouteValue("slug")         // Vary by tip slug
+               .Expire(TimeSpan.FromHours(24))      // Cache tips for 24 hours
+               .Tag("outputcache", "tips", "content")); // Add tags for better organization
 
     // Policy for frequently updated content
     options.AddPolicy("DynamicContent", builder => 
         builder.Cache()
                .SetVaryByHost(true)
                .SetVaryByQuery("*")
-               .Expire(TimeSpan.FromMinutes(5))); // Cache dynamic content for 5 minutes
+               .Expire(TimeSpan.FromMinutes(5))     // Cache dynamic content for 5 minutes
+               .Tag("outputcache", "dynamic")); // Add tags for better organization
 });
 
 // Add response compression
@@ -127,6 +150,9 @@
 	app.UseDeveloperExceptionPage();
 }
 
+// Enable output cache in all environments to test Redis
+// app.UseOutputCache();
+
 // Enable compression and caching early in the pipeline
 app.UseHttpsRedirection();
 

Web/Services/ContentService.cs

@@ -1,36 +1,44 @@
 using Markdig;
 using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.AspNetCore.OutputCaching;
 using System.Text.RegularExpressions;
 using YamlDotNet.Serialization;
 using YamlDotNet.Serialization.NamingConventions;
 using Azure.Data.Tables;
 using Shared;
+using System.Text.Json;
 
 namespace Web.Services;
 
 /// <summary>
-/// Service for managing markdown-based content
+/// Service for managing markdown-based content with Redis distributed caching
 /// </summary>
 public class ContentService : IContentService
-{
-    private readonly ILogger<ContentService> _logger;
+{    private readonly ILogger<ContentService> _logger;
     private readonly IWebHostEnvironment _environment;
-    private readonly IMemoryCache _cache;
+    private readonly IMemoryCache _cache; // Keep for very short-term local caching
+    private readonly IDistributedCache _distributedCache; // Redis cache
+    private readonly IOutputCacheStore _outputCacheStore; // Output cache store for invalidation
     private readonly MarkdownPipeline _markdownPipeline;
     private readonly IDeserializer _yamlDeserializer;
     private readonly TableClient _tableClient;
     private const string TIPS_CACHE_KEY = "content_tips";
-    private static readonly TimeSpan _cacheExpiry = TimeSpan.FromHours(6);
+    private static readonly TimeSpan _distributedCacheExpiry = TimeSpan.FromHours(6);
+    private static readonly TimeSpan _localCacheExpiry = TimeSpan.FromMinutes(5); // Short local cache for frequently accessed data
 
     public ContentService(
         ILogger<ContentService> logger, 
         IWebHostEnvironment environment,
         IMemoryCache cache,
-        TableServiceClient tableServiceClient)
-    {
+        IDistributedCache distributedCache,
+        IOutputCacheStore outputCacheStore,
+        TableServiceClient tableServiceClient)    {
         _logger = logger;
         _environment = environment;
         _cache = cache;
+        _distributedCache = distributedCache;
+        _outputCacheStore = outputCacheStore;
 
         // Configure Markdig without syntax highlighting (using Prism.js client-side instead)
         _markdownPipeline = new MarkdownPipelineBuilder()
@@ -164,25 +172,32 @@ public async Task<List<TipModel>> GetRelatedTipsAsync(TipModel tip, int count =
             .ToList();
 
         return relatedTips;
-    }
-
-    public async Task RefreshContentAsync()
+    }    public async Task RefreshContentAsync()
     {
         _logger.LogInformation("Refreshing content cache...");
 
         try
         {
             var tips = await GetTipsFromAzureTableAsync();
 
-            var cacheEntryOptions = new MemoryCacheEntryOptions()
-                .SetSlidingExpiration(_cacheExpiry)
+            // Update Redis cache
+            var serializedTips = JsonSerializer.Serialize(tips);
+            var distributedCacheOptions = new DistributedCacheEntryOptions
+            {
+                SlidingExpiration = _distributedCacheExpiry
+            };
+            await _distributedCache.SetStringAsync(TIPS_CACHE_KEY, serializedTips, distributedCacheOptions);
+
+            // Update local cache
+            var localCacheEntryOptions = new MemoryCacheEntryOptions()
+                .SetSlidingExpiration(_localCacheExpiry)
                 .SetPriority(CacheItemPriority.Normal)
                 .RegisterPostEvictionCallback((key, value, reason, state) =>
                 {
-                    _logger.LogInformation("Content cache evicted. Reason: {Reason}", reason);
+                    _logger.LogDebug("Local content cache evicted. Reason: {Reason}", reason);
                 });
 
-            _cache.Set(TIPS_CACHE_KEY, tips, cacheEntryOptions);
+            _cache.Set(TIPS_CACHE_KEY, tips, localCacheEntryOptions);
             _logger.LogInformation("Content cache refreshed. Loaded {Count} tips", tips.Count);
         }
         catch (Exception ex)
@@ -227,17 +242,48 @@ private async Task<List<TipModel>> GetTipsFromAzureTableAsync()
         }
 
         return tips;
-    }
-
-    private async Task<List<TipModel>> GetTipsFromCacheAsync()
+    }    private async Task<List<TipModel>> GetTipsFromCacheAsync()
     {
-        if (_cache.TryGetValue(TIPS_CACHE_KEY, out List<TipModel>? tips))
+        // First, check local memory cache for very recent data
+        if (_cache.TryGetValue(TIPS_CACHE_KEY, out List<TipModel>? localTips))
+        {
+            return localTips ?? new List<TipModel>();
+        }
+
+        // Check Redis distributed cache
+        var distributedTipsJson = await _distributedCache.GetStringAsync(TIPS_CACHE_KEY);
+        List<TipModel> tips;
+
+        if (!string.IsNullOrEmpty(distributedTipsJson))
+        {
+            try
+            {
+                tips = JsonSerializer.Deserialize<List<TipModel>>(distributedTipsJson) ?? new List<TipModel>();
+                _logger.LogDebug("Loaded {Count} tips from Redis cache", tips.Count);
+            }
+            catch (JsonException ex)
+            {
+                _logger.LogWarning(ex, "Failed to deserialize tips from Redis cache, falling back to database");
+                tips = await GetTipsFromAzureTableAsync();
+            }
+        }
+        else
         {
-            return tips ?? new List<TipModel>();
+            // Cache miss - load from database
+            tips = await GetTipsFromAzureTableAsync();
+            
+            // Store in Redis
+            var serializedTips = JsonSerializer.Serialize(tips);
+            var distributedCacheOptions = new DistributedCacheEntryOptions
+            {
+                SlidingExpiration = _distributedCacheExpiry
+            };
+            await _distributedCache.SetStringAsync(TIPS_CACHE_KEY, serializedTips, distributedCacheOptions);
+            _logger.LogInformation("Cached {Count} tips in Redis", tips.Count);
         }
 
-        tips = await GetTipsFromAzureTableAsync();
-        _cache.Set(TIPS_CACHE_KEY, tips, _cacheExpiry);
+        // Store in local memory cache for very short term
+        _cache.Set(TIPS_CACHE_KEY, tips, _localCacheExpiry);
 
         return tips;
     }
@@ -326,7 +372,29 @@ private string PostProcessCodeBlocks(string htmlContent)
 		var pattern1 = @"<pre><code class=""language-(\w+)"">";
 		var replacement1 = @"<pre class=""language-$1""><code class=""language-$1"">";
 		htmlContent = Regex.Replace(htmlContent, pattern1, replacement1);
-
 		return htmlContent;
-	}
+	}    /// <summary>
+    /// Invalidate all tips-related cache entries
+    /// </summary>
+    public async Task InvalidateTipsCacheAsync()
+    {
+        try
+        {
+            // Clear distributed cache
+            await _distributedCache.RemoveAsync(TIPS_CACHE_KEY);
+            
+            // Clear local memory cache
+            _cache.Remove(TIPS_CACHE_KEY);
+            
+            // Clear output cache for tips pages
+            await _outputCacheStore.EvictByTagAsync("tips", default);
+            await _outputCacheStore.EvictByTagAsync("content", default);
+            
+            _logger.LogInformation("Tips cache invalidated successfully");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error invalidating tips cache");
+        }
+    }
 }

Web/Services/IContentService.cs

@@ -14,4 +14,5 @@ public interface IContentService
     Task<List<string>> GetTagsAsync();
     Task<List<TipModel>> GetRelatedTipsAsync(TipModel tip, int count = 3);
     Task RefreshContentAsync();
+    Task InvalidateTipsCacheAsync();
 }