What actually went GA
Microsoft describes the guidance as caching patterns, reference architectures and tutorials for applications using Azure SQL Database, Azure Cosmos DB and Azure Database for PostgreSQL. Each guide comes with a fully deployable sample app. The announcement was one of seven Azure Managed Redis updates Microsoft grouped around Ignite 2026. The others include Redis 8 and an agent kit in public preview, and migration tooling and keyspace notifications at GA.
The underlying technical material came a few days earlier. Microsoft published caching pattern architectures, how-to guides and sample code pairing Azure Managed Redis with PostgreSQL, Azure SQL Database and Cosmos DB. Microsoft's pitch is simple. Hot data served from memory takes repeated work off the database.
Those benefits are Microsoft's stated rationale. The posts don't publish a benchmark or a guaranteed speedup, so test with your own workload.
The eight patterns
Microsoft frames them around an online retail store. Most apps combine several, choosing one per data type.
- Cache-aside: Check Redis first. On a miss, read the database and cache the result with a TTL. It's the most common pattern and the easiest place to start. The example is popular product pages.
- Reference-data prefetching: Preload stable data such as categories, tax rates and shipping options, and refresh it when the source changes.
- Write-through: Commit to the database, then write the new value to the cache so readers see it immediately. The example is price and stock updates.
- Event-driven updates: A listener updates or removes cached copies when another system changes the data. The example is warehouse order status.
- Write-behind: Count in Redis, then flush totals to the database in batches. It's for cases where losing a few increments is acceptable, such as view counters.
- Sorted-set ranking: Redis sorted sets keep rankings ready to read, for best-seller and top-rated lists.
- Session and state offload: Keep short-lived, fast-changing state such as carts and sign-in sessions out of the system of record.
- Multi-region caching: Use active geo-replication to keep regional caches in sync.
The database remains the source of truth. The cache only holds copies, and the patterns exist to keep those copies fresh.
Read the coverage matrix before you plan
The samples don't implement every pattern on every database. This is the practical detail that matters.
| Pattern | PostgreSQL | Azure SQL | Cosmos DB |
|---|---|---|---|
| Cache-aside | Yes | Yes | Yes |
| Reference-data prefetching | Yes | Yes | Yes |
| Write-through | Yes | Yes | Yes |
| Event-driven updates | Redis Streams worker | Azure Functions SQL trigger | Change feed with Azure Functions |
| Write-behind | Not listed | Yes | Not listed |
| Sorted-set ranking | Not listed | Not listed | Yes |
| Session and state offload | Not listed | Not listed | Yes |
Microsoft says the samples cover seven of the eight patterns together. They skip multi-region caching because each sample deploys to a single region. Microsoft points readers to its active geo-replication configuration guidance instead.
The Azure Architecture Center has designs for three of the patterns. Each uses one database as its example, and Microsoft says the same design works with any of the three:
- Cache-aside with PostgreSQL
- Write-through with Azure SQL Database
- Event-driven updates with Cosmos DB
Microsoft Learn also has a per-database implementation guide. The Learn pages differ slightly from the samples. The Azure SQL guide describes five patterns in Python, including write-behind. The PostgreSQL guide implements four, in Python, with Microsoft Entra ID authentication. Redis's own blog, which also covers the samples, says the patterns work with any database. Microsoft's post makes the same claim, though its guides and samples cover only the three Azure services.
Trying a sample
Microsoft's walkthrough runs as follows:
- Install the Azure Developer CLI (
azd) and the Azure CLI. - Sign in with
az loginandazd auth login. - Clone the
amr-caching-pattern-samplesrepository. - Change into one sample directory:
azure-sql-retail-sample,postgres-retail-sampleorcosmos-db-retail-sample. - Create an environment with
azd env new <your-env-name>. - Run
azd up. - Open the storefront and follow the sample README to see each pattern in action.
Use a different azd environment name for each sample, or one deployment can overwrite another. The deployed resources bill while they run. When you're finished, Microsoft's cleanup command is azd down --purge --force. Run it, or the meter keeps ticking.
Microsoft's operating advice
The guidance is more useful than a pile of sample code because it includes design rules:
- Cache what's read often and changes rarely. Write-heavy data with little reuse usually isn't worth caching.
- Set TTLs by acceptable staleness. Add a little random jitter so many keys don't expire at the same moment.
- Treat the cache as an optimization. If Redis is unavailable, the app should fall back to the database, with retry logic for both services.
- Co-locate the app, Redis and database in one region to avoid extra network round trips.
- Prefer Microsoft Entra ID over access keys. Every sample uses
DefaultAzureCredential. In Azure it uses the app's managed identity, and locally it uses your developer sign-in, such as Azure CLI. That keeps secrets out of code and configuration. - Watch the right numbers. On the Redis side, track cache hit ratio, evictions and latency. On the database side, track CPU, workers, IOPS or RU/s, depending on the service. Microsoft says a low hit ratio or high evictions usually points to short TTLs or a cache too small for the working set.
Caveats and analysis
The write-through architecture page adds a sharper warning. It says to treat SQL Database as the authoritative store and not to write a new value to Redis as if it's committed when the SQL write fails. That is the kind of failure mode a naive implementation would miss. It's also a good reason to read the architecture pages and not only copy the sample.
Two cautions follow from Microsoft's own wording:
- Samples aren't production designs. They're single-region retail demos. Multi-region consistency, failover behavior and sizing are for you to work out.
- Caching adds complexity. Staleness, invalidation and fallback logic are now part of your application. For modest workloads, tuning queries or database capacity may be the cheaper fix.
This is an educational GA, not a feature GA. For teams already running on Azure SQL, Cosmos DB or PostgreSQL, it's a useful, vendor-curated starting point. Most of its value is in the pattern-to-feature mapping and the sample code.
References
- (Launched) Generally Available: Azure Managed Redis database integration guidance Azure Updates · 2026-11-17T20:00:32Z
- Build faster apps: database caching patterns with Azure Managed Redis techcommunity.microsoft.com
- Write-Through Caching with Azure Managed Redis and Azure SQL Database - Azure Architecture Center learn.microsoft.com