In This Post
- The week in one paragraph
- Application Gateway got a second routing engine
- Multi-pool rules, and the weight that ignores health
- Token validation moved into a regional policy
- Network Watcher: eight entries and one honest limit
- Custom policy reached GA with a hole the same day’s preview does not fill
- What I would act on
- Complete inventory — all 373
- Feed health
- Official Azure references
The week in one paragraph
Ignite 2026 ran on 17 November and the feed shows it: 269 of the window’s 373 items carry that single date, against 52 on the 18th, 19 on the 19th, 24 on the 20th and 9 on the 16th. The loudest single story was data — Azure HorizonDB reached general availability and brought roughly twenty entries with it, from private endpoints and geo-redundant backup to Apache AGE graph performance and fifteen-region availability, while Cosmos DB, DocumentDB, Managed Redis and Database for PostgreSQL each shipped their own cluster of announcements. But the part of the week with consequences for an existing network design was Application Gateway: advanced routing rules, advanced load balancing, centralized user authentication with JWT validation, confidential compute support and a next-generation elastic architecture for v2 all entered public preview on the same day. Three of those change how a request reaches a backend, and the first two together mean a routing rule is no longer a mapping from one listener to one pool. On the security side DDoS Protection custom policy reached general availability, giving fixed protocol thresholds in place of adaptive auto-tuning — and its documentation names NAT Gateway StandardV2 as excluded from that GA release, on the same day a DDoS preview for NAT Gateway v2 IP was announced separately. Network Watcher took eight entries of its own, mostly diagnostics: a connection analyzer, packet capture insights, auto-created connection monitors, rule recommendations, Private Link support and an AI summary of connection troubleshoot results. Beyond networking, Azure Firewall for Containers entered public preview on the 20th, and Azure Linux 4.0, Windows Server 2028 preview and Azure Ebsv6 rounded out the compute side.
Application Gateway got a second routing engine
I wrote about Application Gateway’s listeners, rules and backend pools in #97 a few days ago, and the model there is simple: a listener matches, a rule fires, and the rule names one backend pool, either directly or through a URL path map. The advanced routing rules preview adds a second, parallel model on top of that one.
An advanced routing map is a container holding advanced routing rules plus a default backend pool, default backend HTTP settings and an optional default rewrite rule set. Each rule has a priority, a condition set, a target pool and settings. Application Gateway evaluates the rules in ascending priority order and the first match wins; if nothing matches, the request goes to the map’s default pool. The documentation is explicit that this rule priority is not the same number as the primary routing rule priority, which is the kind of overlap that produces a confident wrong answer during an incident.
The matching logic has two layers of boolean, and they run in opposite directions. Within a condition set, all conditions must match — a logical AND. Within one condition, any of the listed property values matches — a logical OR. Patterns are RE2-compatible regex only, which rules out backreferences and lookaheads.
| Property | Limit |
|---|---|
| Advanced routing maps | 100 per gateway |
| Advanced routing rules per map | 100 |
| Advanced routing condition sets | 10,000 per gateway |
| Conditions per condition set | 5 |
| Property values per condition | 5 |
| Condition property value | 128 characters |
| Property value regular expression | 128 characters |
The headline numbers are generous — 100 maps of 100 rules each — and the small numbers are where a design actually lands. Five conditions per set and five values per condition is tight for anything resembling a tenant allowlist, and a 128-character ceiling on the regex means the pattern has to stay a pattern rather than becoming an enumeration.
Three restrictions matter more than any of the limits. During public preview the service supports only header-based conditions, even though the documented condition types are Header, QueryString, ClientIP, Method and Path — so the path-based and client-IP routing the feature is built around cannot be configured yet. The feature is not supported for multisite listeners or the Layer 4 TCP/TLS proxy, and an advanced routing rule can be associated only with a basic frontend listener; a multi-tenant gateway fronting several host names is therefore out of scope for now, which is awkward given that multi-tenant routing is the first use case the documentation lists. And WAF association works at the gateway or listener level only — there is no per-rule WAF policy. WAF still runs first, so a blocked request never reaches the routing engine, but you cannot vary the policy per advanced rule.
One detail worth copying into a runbook: URL normalisation happens before the Path condition is evaluated. An incoming URL of /foo%2Fbar is compared against the decoded /foo/bar, not the raw encoded string. That is the correct behaviour and the opposite of what a hand-written matcher usually does.
Multi-pool rules, and the weight that ignores health
The advanced load balancing preview is the bigger conceptual change of the two. A routing rule can now be associated with up to five backend pools, and distribution happens in two independent stages: pool selection, then server selection inside the chosen pool.
| Stage | Options | What it keys on |
|---|---|---|
| Pool selection | Weighted distribution, or priority-based selection — not both | Whole-number weights 0 to 100, or priority 1 to 5 plus a minimum healthy percentage 0 to 100 |
| Server selection | Round Robin (default), Weighted Round Robin, Least Connections | Per-server weights 0 to 100, or active connection counts |
The two stages are genuinely independent — weights across pools with Least Connections inside each is a valid configuration — and server selection belongs to the pool, while weights and priorities belong to the rule. A pool shared across rules therefore carries one server algorithm everywhere, and changing it changes every rule.
The trap is in the weighted path, and the documentation states it plainly: weighted distribution doesn’t consider pool health and doesn’t move an unhealthy pool’s traffic share elsewhere. If the selected pool has no healthy servers, requests fail. Health probes still decide which servers inside the chosen pool can take a request, but the choice of pool is made before health is consulted. A canary split of 8 and 2 — a total weight of 10, so an 80% and 20% share — keeps sending a fifth of the traffic at a dead canary. Priority-based selection is the health-aware option, and the documentation says so in as many words.
Priority-based selection has its own sharp edge, and it is a good one: the minimum healthy percentage means failover happens before a pool is fully down. The documented example is a 60% requirement with a five-server primary at priority 1 and a four-server standby at priority 2. Lose three primary servers and the primary is 2 of 5 healthy, or 40%; traffic moves to the standby while two primary servers are still serving. That is deliberate, and it is a different threshold from a probe’s own unhealthy count — the per-server probe semantics I covered in #95 still decide what “healthy” means for each member.
Two consequences follow that are easy to miss:
- Scaling out can trigger a failover. New scale-set instances count as unhealthy until they pass a probe, so growing from four healthy instances to eight total instances makes the pool 50% healthy. Against a 60% requirement it does not qualify again until enough new instances pass. Adding capacity moves traffic away.
- Cookie affinity defeats the health model. A pool with affinity enabled issues an
ApplicationGatewayPoolAffinitycookie, and for a client holding a valid one the pool’s health is not checked at all — that client can stay on an unhealthy pool until no server in it is healthy, at which point its requests simply fail. Weights then govern where new sessions go, not where existing ones are.
And one quiet behaviour that will cost someone an afternoon: Least Connections isn’t applied while cookie-based affinity is enabled. Configure both and you get affinity, with Round Robin or the configured weights behind it. There is no error; the algorithm you selected just does not run.
Weighted Round Robin behaves better than weighted pools under failure: it skips an unhealthy server and redistributes using the remaining relative weights, so weights of 6, 3 and 1 become roughly 75% and 25% when the weight-6 server goes. It also carries a backend-type restriction — IP and FQDN addresses only, and a single NIC-associated virtual machine or scale set makes the whole pool ineligible, mixed pools included. One more counting rule: health is calculated over resolved backend IP addresses, not names, so an FQDN resolving to four addresses contributes four servers. Equal weights on two FQDNs do not give them equal traffic if they resolve to different numbers of healthy addresses. All of this needs Standard_v2 or WAF_v2 — the Basic SKU is excluded — and the autoscaling behaviour from #98 is what makes the scale-out failover above a realistic Tuesday rather than a thought experiment.
Token validation moved into a regional policy
Application Gateway can already validate JSON Web Tokens issued by Microsoft Entra ID before a request reaches a backend. What entered preview this week is centralized validation: the configuration becomes an authentication policy resource that can be associated with routing rules across several gateways, so issuer, audience and the unauthenticated-request action are defined once. The policy is a regional resource and must sit in the same region as the gateways that use it, which means a multi-region front end still needs one policy per region.
Validation covers the token signature, issuer, audience and lifetime. On success the gateway forwards an x-msft-entra-identity header to the backend as tenantId:oid — so the backend gets a verified identity rather than a repeat of the parsing work. Choosing the Allow action for unauthenticated requests forwards the request without that header, which is the right design: a backend that trusts the header cannot be fooled by its absence.
| Scenario | HTTP status | Identity header |
|---|---|---|
| Valid token, action Allow | 200 | Present |
| Invalid token, action Deny | 401 | Absent |
| Missing token, action Deny | 401 | Absent |
Missing oid claim, action Deny | 403 | Absent |
The 403 is the interesting row. A token that validates but carries no oid claim is not an authentication failure, so it is not a 401 — the gateway has nothing to put in the identity header, and says so with a different code. Worth knowing before someone writes an alert that treats 401 as the only auth signal.
Preview constraints are real and specific. An HTTPS listener is required; HTTP is not supported. Basic and advanced routing rules are eligible, including an advanced rule with a path condition, but the separate path-based routing rule type is not supported during preview — which pairs awkwardly with the advanced routing preview supporting only header conditions for now. The gateway must also reach the Entra metadata endpoints over TCP port 443, and needs Standard_v2 or WAF_v2. And the two previews coexist: the earlier JWT validation preview stays active for existing policies, existing configurations are not migrated automatically, and new work should use the centralized policy.
Network Watcher: eight entries and one honest limit
Network Watcher took eight entries in the window — a connection analyzer, packet capture insights, auto-created connection monitors, rule recommendations, Private Link support, resource health and topology in connection monitor tests, an AI summary of connection troubleshoot results, and a networkInterfaceIP field on VNet flow logs. Most of that is diagnostics ergonomics rather than new measurement, and the measurement underneath has limits worth knowing before you plan a monitoring estate around it.
| Scale limit | Value |
|---|---|
| Connection monitors per subscription per region | 100 |
| Test groups per connection monitor | 20 |
| Sources and destinations per connection monitor | 100 |
| Test configurations per connection monitor | 20 |
Tests are a cross product, not a list: a test group with 3 sources, 2 destinations and 2 test configurations creates 12 tests, and a test is the finest grain at which data exists. That multiplication is how a modest-looking configuration reaches the 100-endpoint ceiling.
Two defaults decide what you see when you have not set thresholds. If no threshold is specified, a test fails only when the checks-failed percentage reaches 100 — a partial outage reads as a pass. In that case connection monitor assigns its own warning thresholds: 750 milliseconds round-trip time for TCP and ICMP, and 10 percent checks failed. If you do set a threshold, exceeding 80 percent of it marks the test as Warning. And the retention asymmetry matters: Azure Monitor keeps metrics for 30 days by default while Log Analytics keeps them as long as you configure, so a post-incident review reaching back a quarter has to come from the workspace.
The honest limit is the endpoint state machine. Connection monitor re-evaluates endpoint status once every 24 hours. A VM deallocated mid-cycle produces an indeterminate state rather than a reported failure, because the data is simply missing from the path — and for scale sets the documentation recommends random instance selection within a coverage level instead of pinning specific instances, precisely because scaled-down instances cannot be recognised inside the cycle. The five coverage levels are Low, Below Average, Average, Above Average and Full.
The resource-metrics-in-topology feature is the one I would actually use: select an Azure resource hop in a failing test’s topology and see that resource’s own metrics beside the test’s loss and latency, so a degraded path can be attributed to a hop rather than inferred. It is in preview, and it is available only for Azure resource hops — nothing for on-premises or internet hops, which is where the ambiguity usually lives. Two other standing facts the page states plainly: connection monitor (classic) is deprecated and no longer available, and on-premises sources must be Azure Arc-enabled, because the Log Analytics agent is no longer supported for them.
Custom policy reached GA with a hole the same day’s preview does not fill
DDoS Protection normally sets its detection thresholds by adaptive, machine-learning auto-tuning per protected resource — the behaviour behind the IP and Network tiers I covered in #87. Custom policy, now generally available, replaces that with fixed thresholds per protocol. Each detection threshold rule names a protocol, a threshold in packets per second, and a direction, which is always inbound.
| Protocol | Minimum threshold (packets per second) | Maximum threshold (packets per second) |
|---|---|---|
| TCP | 50,000 | 2,000,000 |
| UDP | 20,000 | 200,000 |
| TCP SYN | 1,000 | 100,000 |
The ceiling for TCP is ten times the ceiling for UDP, and the TCP SYN floor of 1,000 packets per second is the tightest trigger available anywhere in the feature — which is the right shape, since a SYN flood is cheap to send and expensive to absorb. The override is per protocol, not per policy: configure a custom threshold for one protocol and Azure disables auto-tuning for that protocol only, leaving the others adaptive. That is a better default than it sounds, because it means a single tuned protocol does not quietly turn off learning everywhere else.
The part to read twice is the exclusion. The documentation states that NAT Gateway StandardV2 public IP addresses aren’t supported in the initial generally available release, that the exclusion applies to all management interfaces, and — explicitly — that the separate DDoS Protection preview for NAT Gateway StandardV2 doesn’t add custom-policy support. Both things were announced in the same window: custom policy went GA and DDoS support for NAT Gateway v2 IP went to public preview, on 17 November. Read as a pair they look like one capability; they are not. A NAT gateway v2 deployment can be protected and still cannot carry a tuned threshold.
Two more operational notes. A public IP prefix does not expose the same association as an individual public IP address, and a policy should not be configured on the prefix resource — so a design that allocates from a prefix has to associate per address. And an association does not follow a replacement: delete or replace a public IP and the policy association does not transfer, which makes an active/standby failover a silent downgrade to adaptive tuning unless each eligible address is associated in advance. Government-cloud portal availability is a separate rollout and should not be inferred from the public cloud.
What I would act on
- Check whether a DDoS custom policy association survives your failover. If you run active/standby on two public IP addresses, associate the policy with both now — the association does not move with the traffic, and the failure mode is a quiet return to adaptive thresholds at the exact moment you wanted fixed ones. If any protected endpoint is a NAT Gateway StandardV2 address, note that custom policy does not reach it in this release.
- Do not plan a canary on weighted pool selection. It is the obvious use of the new multi-pool rules and it ignores pool health. If the canary pool dies, its share of requests dies with it. Use priority-based selection where failover matters, and accept that weighted distribution is a traffic-splitting tool, not an availability one.
- If you use cookie-based affinity, write down that Least Connections will not run. The two are mutually exclusive and nothing reports the conflict. The same applies to pool affinity and pool health: an affinity cookie pins a client to a pool whose health is never re-checked.
- Set explicit thresholds on connection monitor tests. With none set, a test fails only at 100 percent checks failed, which means a half-broken path reports healthy. The automatic 750 millisecond and 10 percent values only produce warnings.
- Treat the Application Gateway previews as direction, not plan. Header-only conditions, basic listeners only, no per-rule WAF and no path-based rule type under the authentication policy add up to a feature set that cannot yet express the designs it is advertised for. Worth prototyping; not worth committing a topology to.
Complete inventory — all 373
Every announcement in the 16–20 November 2026 window, from 29 sources that reported items, after deduplication and after excluding items already covered in an earlier roundup. The arithmetic below reconciles to the raw total, so the completeness claim is checkable rather than asserted.
| Step | Count | Why |
|---|---|---|
| Reported across all sources | 551 | Raw in-range items, before any deduplication |
| Less the Azure Updates RSS mirror | −173 | The RSS feed re-publishes the same 173 items the JSON archive already supplies |
| Less duplicates inside one source | −0 | No source re-listed the same URL this week |
| Less items already published in an earlier weekly | −5 | Four Tech Community posts and one Sentinel announcement already covered in #14 |
| Inventory rows | 373 | Independently confirmed against 378 rows parsed from the inventory body, less the same 5 exclusions |
Feed health
Reported by fetch_azure_week.py --audit on 21 November 2026, before the inventory was built.
| Condition | Count | Detail |
|---|---|---|
| Sources probed | 46 | Plus the Azure Updates JSON archive as the backbone, which holds 10,215 records and is queried by range rather than sliced |
| Broken or empty | 1 | The ISE blog feed answered HTTP 404 again, as it did last week — reported rather than silently empty, and it has contributed no in-range items in previous windows |
| Reported stale | 3 | Identity devblog, Azure Government, and the FastTrack Tech Community blog |
| No feed, checked by hand | 4 | AKS blog, Azure VMware Solution blog, Microsoft Fabric blog, Ignite/Build announcements |
| Sources reporting items | 29 | Of the 46 probed |
| Sources contributing rows | 28 | After deduplication and cross-week exclusions — the RSS mirror contributed nothing new |
| Feeds saturated in range | 3 | TC Apps on Azure, TC Integration and TC AI Foundry each returned 20 in-range items from a feed that holds 20 |
That last row is the one to take seriously. A feed whose entire window of retained items falls inside the requested range has no older item to prove nothing aged out, so for those three blogs the inventory is a floor rather than a complete count. All three publish into the Ignite announcement stream, which is exactly when a 20-item cap is most likely to bite. The Azure Updates archive is immune to this by construction — it is queried by date range and holds 10,215 records — which is why it is the backbone and the Tech Community blogs are not.
Official Azure references
- Advanced routing rules on Azure Application Gateway — the preview statement and listener restrictions, the map and rule hierarchy, priority ordering and the default pool, the AND/OR evaluation split, the full property limits table, the header-only preview constraint and five documented condition types, RE2-only pattern matching, the Method value list and case rules, CIDR-only ClientIP, path normalisation before matching, and WAF ordering with no per-rule association
- Advanced load balancing on Azure Application Gateway — the two-stage distribution model, the five-pool association limit, weight and priority ranges, the 8/2 weighted worked example, the health-blind behaviour of weighted pools, the 60% minimum-healthy failover example, recovery without a return delay, Round Robin as default, the 6/3/1 redistribution example, Least Connections disabled under cookie affinity, the pool-affinity cookie and unhealthy pools, resolved-address health counting, the four-to-eight scale-out example, SKU and protocol limits, the Weighted Round Robin backend restriction, and Dedicated Backend Connection with single pools
- JSON Web Token validation in Azure Application Gateway — the centralized preview statement, what is validated, the regional policy requirement and multi-gateway association, the identity header format and the Allow behaviour, the supported rule types and the unsupported path-based type, the HTTPS-only listener requirement and port 443 reachability, the status-code outcome table including the 403 for a missing oid claim, the SKU prerequisite, and the coexistence of the earlier preview without automatic migration
- Connection monitor overview, Azure Network Watcher — the TCP/ICMP/HTTP measurement model and unified topology, the four scale limits, the twelve-test cross product, the five coverage levels, the 24-hour re-evaluation and indeterminate state, the 100 percent failure default and the 80 percent warning rule, the automatic 750 millisecond and 10 percent thresholds, the 30-day metric retention and one-minute granularity, the resource-metrics-in-topology preview and its Azure-hops-only limit, the Arc-only on-premises source requirement, the classic deprecation, and the current metric set with TestResult values
- What is Azure DDoS Protection custom policy — the override of adaptive auto-tuning and the shape of a detection threshold rule, the TCP, UDP and TCP SYN packets-per-second ranges, the per-protocol scope of the override, the NAT Gateway StandardV2 exclusion from the initial GA release, the supported resource list and its eligible-configuration caveat, the public IP prefix restriction, the non-transferring association on IP replacement, and the separate Government-cloud rollout
- User authentication in Azure Application Gateway — the interactive sign-in half of the same authentication policy preview, alongside JWT validation (no claims drawn from it)
- Connection troubleshoot overview, Azure Network Watcher — the agentless experience behind this week’s connection analyzer and AI summary entries (no claims drawn from it)
- Azure DDoS Protection features — the adaptive tuning a custom policy overrides, protocol by protocol (no claims drawn from it)
Comments