A cloud-connected database system routes automated updates to a dashboard, with status, deletion, scheduling, and alerts.
Azure Managed Redis now has keyspace notifications as a production-ready feature. Microsoft's Azure Updates entry for November 17, 2026 carries the "Launched" status, which Azure defines as fully released and available to all Azure customers. Microsoft's Ignite 2026 roundup for the service lists the feature as item seven of seven and labels it general availability.

For anyone who has been planning an Azure Cache for Redis migration, this closes a gap that has been in the documentation for a while.

A cloud-connected database system routes automated updates to a dashboard, with status, deletion, scheduling, and alerts. What Microsoft announced​

Applications can subscribe to Redis Pub/Sub notifications for key updates, deletions, and expirations. Microsoft's example is an application that subscribes to expiration events and uses them to trigger downstream logic. The practical pitch is that an app can react to selected cache changes without hammering the cache with repeated polling requests.

The feature has been through a preview phase. Microsoft's Build 2026 post listed keyspace notifications as "in preview" to enable event-driven application patterns. The GA label arrived roughly five and a half months after that post.

Why migration teams care​

For a long time this was a documented difference between the old and new services. Microsoft's migration guide says keyspace notifications are supported in Azure Cache for Redis but aren't currently available in Azure Managed Redis. Third-party migration guides repeated the point, and one lists it as a missing feature when comparing the two services. One such guide, from acemq.com, names it alongside the missing Entra ID RBAC support.

Those pages predate the GA announcement, so treat that limitation as the former state of play. If your migration checklist still lists "keyspace notifications: unsupported," it's time to update it.

The timing also matters because Azure Cache for Redis has announced a retirement timeline for all SKUs, and Microsoft recommends moving to Azure Managed Redis as soon as you can. An app that relied on expiry events for session cleanup or cache-driven workflows no longer has to wait on a feature gap.

How keyspace notifications work​

This is standard Redis behaviour. According to the Redis documentation, there are two kinds of event for each operation:

  • Key-space notifications are published on channels such as __keyspace@0__:mykey. The message is the name of the event.
  • Key-event notifications are published on channels such as __keyevent@0__:del. The message is the name of the affected key.

A DEL on mykey in database 0 therefore produces both messages. You can enable just one kind if you only need a subset.

Turning it on in the Azure portal​

Microsoft Learn documents the portal path for an existing Azure Managed Redis cache:

  1. Open the Azure Managed Redis resource in the Azure portal.
  2. Select Advanced settings.
  3. Enable Keyspace notification.
  4. In the event types field, enter an event-type string.
  5. Select Save.

The value "KEA" enables notifications for most events, and "K" or "E" is required to receive keyspace notifications. In Redis's syntax, K means keyspace events and E means keyevent events. Letters such as x (expired events) and g (generic commands like DEL and EXPIRE) narrow what you receive. If you only care about expiry, Microsoft's page shows moving from KEA to Ex.

Turning it on with an ARM template​

The same Learn page documents an ARM template route. The key piece is the notifyKeyspaceEvents property on the database resource, set to KEA in the example. The sample deploys with az deployment group create, and Microsoft says that redeploying with a changed value updates the notification settings without data loss.

Two cautions apply to the sample:

  • It uses API version 2026-02-01-preview, a Balanced_B5 SKU, port 10000, OSSCluster, NoEviction, persistence off, and public network access enabled. These are example values, not a recommended production setup.
  • If your cache wasn't deployed from that template, Microsoft says your own template must include the existing cluster and database configuration, so other properties aren't overwritten.

Testing it​

The Learn walkthrough uses two terminals in Redis Insight or redis-cli. One is a subscriber and the other is an operator:

  1. Run CONFIG GET notify-keyspace-events to confirm the string is set.
  2. In the subscriber, run PSUBSCRIBE __keyevent@0__:* __keyspace@0__:* to watch everything. You can also subscribe to a single event with SUBSCRIBE __keyevent@0__:set, or to a single key with SUBSCRIBE __keyspace@0__:mykey.
  3. In the operator terminal, run SET mykey "hello", EXPIRE mykey 10, and DEL mykey.
  4. Confirm the subscriber shows the events and the affected keys.

If the subscriber stays silent, check the string first. Without K or E, no keyspace notifications arrive. A third-party glossary also notes that until the setting is applied, no notifications are delivered and no error is raised. That's a plausible source of "it's broken" tickets, though it comes from a vendor glossary rather than Microsoft.

Caveats before you build on it​

Pub/Sub is fire-and-forget. The Redis documentation is explicit that if a subscriber disconnects and reconnects, events delivered in the meantime are lost. These notifications suit reactive logic where a missed event is tolerable or handled separately. They are not a durable event log, and nothing in the sources reviewed promises Azure-specific delivery guarantees beyond standard Redis behaviour. If an expiry event must trigger a billing action, pair it with a reconciliation job.

Expiry timing is not exact. Redis expires keys when they are accessed or through an incremental background process. The documentation warns there are no guarantees the expired event fires the moment the TTL reaches zero. With many TTL keys and little access, the delay can be significant.

Clusters are per-node. Redis states that keyspace events are node-specific in a cluster, so clients need to subscribe to each node to see every event. Azure Managed Redis is clustered by default, so this matters if you're moving from a non-clustered cache. That is a Redis general rule. I'm not claiming how Azure's proxy and endpoint layer handles it, so test your subscriber design against a real instance.

There is overhead. Redis notes notifications are off by default because they use some CPU. Enable only the event classes you need rather than defaulting to KEA everywhere.

Event coverage may be narrower than Redis's full list. Microsoft's announcement names updates, deletions, and expirations. Redis documents many more event classes. Don't assume everything on the Redis list behaves identically on Azure Managed Redis until you've tested it.

Documentation is out of step​

Microsoft's own pages don't fully agree yet. The Learn configuration page still has "preview" in its title and uses a preview API version in its template. The migration guide still says the feature is unavailable. The GA claim rests on Microsoft's November 17 announcement and the Azure Updates entry. Expect the docs to catch up, and check the current API version before standardising a template.

The sources reviewed don't establish regions, pricing, SLA changes, or SKU restrictions for the GA release. Verify those against your own subscription before committing.

Using it with Azure Functions​

Azure Functions has a RedisPubSubTrigger that can consume these channels, with samples for __keyspace@0__: and __keyevent@0__: patterns. This is separate from the GA announcement, but the Functions docs list some limits that affect design:

  • The trigger isn't supported on Consumption or Flex Consumption plans, because Redis Pub/Sub needs clients that are always listening. Functions there might miss messages.
  • It shouldn't be scaled out to multiple instances, since each instance processes every message and you get duplicates.
  • The docs say it can't listen to keyspace notifications on clustered caches. That sits awkwardly beside Azure Managed Redis being clustered by default. Check the current Functions docs and test before building around it.
  • Azure Managed Redis uses port 10000 rather than 6380 or 6379.

Bottom line​

This is a modest but useful capability. It matters most to teams that depended on keyspace events in Azure Cache for Redis and were blocked from moving. Enable only the event types you need, treat the messages as best-effort signals, and test cluster and Functions behaviour against a real instance before production. Then update your migration checklist.

 

References

  1. (Launched) Generally Available: Azure Managed Redis keyspace notifications Azure Updates 2026-11-17T20:00:32Z
  2. Enable Redis Keyspace Notifications in Azure Managed Redis (preview) - Azure Managed Redis learn.microsoft.com
  3. Redis keyspace notifications | Docs redis.io