Lesson: Caching Strategies and Azure CDN

Introduction

In modern distributed systems, performance and latency are critical to user experience. Every round-trip to a database or a remote API introduces latency. Caching is the practice of storing copies of data in a temporary storage location (the cache) so that future requests for that data can be served faster.

By implementing caching, you reduce the load on your backend origin servers, decrease bandwidth costs, and significantly improve the responsiveness of your application. Azure Content Delivery Network (CDN) acts as a global caching layer, placing your content physically closer to your users, effectively minimizing the "speed of light" delay.

Understanding Caching Strategies

Caching isn't a "one-size-fits-all" solution. You must choose a strategy based on how often your data changes and how critical it is that the user sees the absolute latest version.

1. Cache-Aside (Lazy Loading)

This is the most common pattern. The application code first checks the cache. If the data exists (a "cache hit"), it returns it. If not (a "cache miss"), the application fetches the data from the database, updates the cache, and then returns the data.

Best for: Read-heavy workloads where data doesn't change frequently.

2. Write-Through

The application updates the cache and the database simultaneously. This ensures the cache is always consistent with the database but adds latency to write operations.

Best for: Systems where data consistency is more important than write speed.

3. Time-to-Live (TTL)

TTL is a setting that defines how long a piece of data remains in the cache before it is considered "stale" and must be re-fetched from the origin.

Azure CDN: Bringing Content to the Edge

Azure CDN is a global solution for delivering high-bandwidth content. It caches static assets (images, CSS, JavaScript, videos) at "Points of Presence" (PoPs) located around the world.

How it Works:

1. A user requests an image from your website.
2. The request is routed to the nearest Azure CDN PoP.
3. If the PoP has the image cached, it returns it immediately.
4. If not, the PoP fetches the file from your "Origin" (e.g., Azure Blob Storage or a Web App), caches it, and then serves it to the user.

Practical Example: Configuring CDN with Azure Blob Storage

If you are hosting static assets in Azure Blob Storage, you can front them with Azure CDN to reduce latency.

Conceptual Workflow:

1. Create an Azure Storage Account.
2. Enable "Static Website" hosting.
3. Create an Azure CDN Profile and Endpoint.
4. Set the Origin Hostname to your Storage Account's web endpoint.

Tip: Always use HTTPS. Azure CDN supports custom domains with managed SSL certificates provided by Azure at no extra cost.

Code Example: Controlling Cache with HTTP Headers

The browser and CDN respect standard HTTP headers to determine how to cache content. You can set these in your application code (e.g., in an ASP.NET Core controller):

[HttpGet]
[ResponseCache(Duration = 3600, Location = ResponseCacheLocation.Any)]
public IActionResult GetProductImage(int id)
{
    // The browser and CDN will cache this response for 1 hour (3600 seconds)
    return File(imageBytes, "image/jpeg");
}

Key Headers:

• Cache-Control: public, max-age=3600: Tells the CDN/Browser to cache the file for 1 hour.
• Cache-Control: no-cache: Forces the client to revalidate with the origin before using the cached version.
• ETag: A unique identifier for a specific version of a resource. If the ETag matches, the server returns 304 Not Modified, saving bandwidth.

Best Practices

1. Cache Static Assets Aggressively: Files like logos, fonts, and CSS rarely change. Use long TTLs (e.g., 30 days or more) for these.
2. Use Versioning for Cache Busting: Instead of updating styles.css, rename it to styles.v2.css. This ensures users get the new file immediately without needing to clear their caches.
3. Monitor Cache Hit Ratio: Use Azure Monitor to track your Cache Hit Ratio. If your ratio is low, your origin server is doing unnecessary work.
4. Compress Content: Enable Gzip or Brotli compression on your CDN endpoint to reduce the size of transmitted text files.
5. Secure Your Origin: Ensure your origin server only accepts traffic from the Azure CDN IP ranges to prevent users from bypassing the cache.

Common Pitfalls

• Over-Caching Dynamic Data: Never cache sensitive user data (like PII or account balances) at the CDN level. If you must cache dynamic data, ensure you use proper Vary headers or private cache directives.
• Ignoring the "Thundering Herd" Problem: When a popular cache item expires, thousands of requests might hit your database simultaneously. Use Cache Locking or Probabilistic Early Recomputation to mitigate this.
• Forgetting to Purge: If you deploy a breaking change to a CSS file, you may need to perform a "Purge" on the Azure CDN endpoint to clear the stale assets globally.

Important: Purging the CDN can be expensive in terms of performance if done too frequently. Use it as a last resort, not as part of your standard deployment pipeline.

Key Takeaways

• Caching improves performance by moving data closer to the user and reducing backend load.
• Azure CDN is essential for static assets, providing global scalability and reduced latency.
• Cache-Aside is the most common pattern for application-level caching, while TTL-based caching is standard for CDN assets.
• HTTP Headers are the primary mechanism for controlling how caches behave.
• Cache Busting (Versioning) is the most reliable way to ensure users see updates without sacrificing the benefits of long-term caching.
• Monitor your hit ratio regularly to ensure your caching strategy is actually providing the intended performance gains.