One Gateway, Sixty-Four MCP Servers, and a Question About Authorization

Azure added a capability on November 2 that a lot of teams running agents on Kubernetes have been building by hand for months. Application Gateway for Containers now understands Model Context Protocol traffic.
The update, tracked as AZ576388, is three features landing together: protocol-aware MCP routing, JWT validation, and a private frontend with no public IP. Individually they are ordinary gateway features. Together they describe the shape of an MCP deployment that has outgrown a single server.
The resource
The core of it is a custom resource called MCPRoute, at alb.networking.azure.io/v1alpha1. It attaches to a standard Gateway API Gateway, which matters for anyone already running Gateway API: you are not adopting a parallel ingress system, you are adding a route type.
There is a configuration step that will cost you an afternoon if you skip it. The listener has to explicitly allow this route type, through allowedRoutes.kinds, with the group set to alb.networking.azure.io and the kind set to MCPRoute. Without that, the route simply will not attach, and the error will not tell you why in plain language.
The route itself is ordinary. parentRefs points at the listener, hostnames carries the public domain, path is the published path and defaults to /mcp, and backendRefs points to Kubernetes services and ports. If a backend serves its MCP endpoint at a different path, backendRefs[].path rewrites it, so you can publish /engineering and forward to /mcp internally.
The aggregation is the product
One backend reference is a pass-through. The gateway forwards MCP requests as they arrive, which is right when one team owns all the capabilities or when that server has already aggregated its own downstream systems.
Multiple backend references are where this stops being plumbing. The gateway merges them into a single logical endpoint. When a client sends tools/list, resources/list or prompts/list, the gateway fans the request out to every backend and merges the responses into one catalogue.
Capability names get namespaced to avoid collisions. A tool called get_order in a service named contoso-tools appears to clients as contoso-tools__get_order. When a client calls the prefixed name, the gateway strips the prefix and routes to the backend that owns it.
Three consequences follow, and the documentation spells them out.
The service name becomes the namespace clients see. Publishing a route therefore freezes that name, because renaming the service renames every tool the client knows. This is the kind of decision that looks cosmetic in a manifest and turns into a breaking change eighteen months later.
A single route can reference at most 64 backends. That number is a real ceiling, and hitting it means splitting by domain rather than by team.
Backends have to be protocol-compatible. If one of them implements MCP in a way that produces a malformed discovery response, the merged catalogue degrades, and the failure looks like the gateway is broken rather than one backend being non-compliant. Give slow downstream systems generous timeouts, because a combined endpoint is never faster than its slowest member.
Stateful servers and session affinity
Some MCP servers keep state in memory after initialize. For those, the gateway supports sessionAffinity on the backend, pinning a session to the pod that performed the handshake.
The documentation is honest that this is best-effort. If the pinned pod is deleted or becomes unavailable, requests fall back to normal load balancing rather than failing. The logical conclusion is that MCP servers have to tolerate losing a session, and anything important belongs outside the pod.
There is also a reverse recommendation worth quoting: if a backend does not need affinity, do not turn it on. Stateless services scale and recover more predictably with it off.
JWT, and the order of operations
Authentication runs through an AuthPolicy resource, attachable to the MCPRoute, to its parent gateway, or to the managed ApplicationLoadBalancer. The gateway validates the token's signature, issuer, expiry and audience before forwarding MCP traffic.
Execution order is fixed at three layers. WAF evaluates first, then JWT validation confirms identity, then MCP routing handles and forwards. One practical consequence: WAF sees the original request, and so do the logs.
Two scoping traps. When a listener carries several MCP routes, a WAF policy attached to one route does not automatically protect the others, so policies have to be applied per route. And a route that references a service in another namespace needs both the namespace field and a ReferenceGrant in the service's namespace, or the route reports ResolvedRefs=False with reason reference-not-permitted.
The sentence to copy into your design doc
The gateway can publish OAuth protected resource metadata, so MCP clients can discover the authorization server and supported scopes. Immediately after describing that, the documentation adds a line that deserves to be framed.
Publishing scopes is not the same as enforcing authorization. The MCP server remains responsible for checking roles, scopes, permissions and resource ownership.
That is the honest boundary. The gateway can answer who you are. It cannot answer whether you are allowed to do this thing to this record. Edge validation of the audience claim is still the right thing to do, because the MCP spec forbids token passthrough: a server should never accept a token that was not issued for it, since a failed audience check produces a confused deputy and a broken audit trail. But validating the token at the edge does not move the authorization decision there.
Anyone who reads "we put auth at the gateway" as "we are done with auth" will ship an agent that can call every tool its token can reach.
The private frontend, and a topology gotcha
The third feature removes the public IP from the gateway frontend entirely. The frontend is then reachable only through approved Azure Private Link private endpoints, each of which can be approved or rejected manually.
The value is cross-boundary. Private endpoints work across virtual networks, subscriptions, Entra tenants and regions, without VNet peering, and they tolerate overlapping address space, which is the obstacle that usually kills private connectivity projects. One gateway resource can run a public frontend and a private frontend at the same time.
One trap to know before you draw the diagram. If a firewall sits in front of the gateway, source NAT makes the gateway see the firewall's IP rather than the client's. Logs and rate limiting both suffer. When client IP matters, the gateway goes in front of the firewall.
Why this had to be one release
MCPRoute is the routing layer. AuthPolicy is the authentication layer. The private frontend is the network isolation layer. Shipping them together is what lets a platform team hand a team one managed HTTPS endpoint instead of assembling an aggregator, a service mesh and a firewall rule set.
The alternative, which many teams are living with right now, is a custom aggregator process that holds a list of MCP servers, merges their catalogues, and gets rebuilt every time a new one appears. That works for five servers and collapses at twenty, because the aggregator becomes a stateful service that nobody owns.
Sixty-four backends behind one name is a genuinely useful shape. The namespacing convention is the part that will be copied by every other gateway vendor within a quarter, because it solves the hard problem: two teams both want a tool called search, and neither wants to rename it.
The part that will not be copied as easily is the discipline the documentation asks for. A gateway that merges catalogues makes it trivially easy to expose a capability you did not intend to expose. Before you attach a backend, decide whether its tools should be reachable by every client that can reach the route. If the answer is no, the route boundary is your authorization boundary, and that is a decision, not a default.
Related articles
Chinese text in video always turns to mush. Dreamina handed the typesetting to code
Dreamina launched Motion Studio on November 10. It no longer generates frames; the model writes code that lays out text, shapes and pacing. Chinese titles stop blurring, but whether the content is right is still on you.
A community spreadsheet of taps that turns off the ads inside Chinese Android builds
A no-root tool that switches off the ads Chinese phone makers ship inside the system UI. Its method is a hand-written tap script per phone model, maintained by volunteers every time a ROM moves. It works, and the maintenance is the point.
GPT Image 2.6 held the token price and raised the bill
GPT Image 2.6 kept every token rate from 2.5 and still costs more per image, because more of the work now happens in output tokens. Eleven days into the ramp, the pricing structure says more than the leaderboard does.
Someone rebuilt IDM from the outside and wrote down what they did not touch
A Rust reimplementation of Internet Download Manager claims 5x the speed and 86 languages. The more interesting document is the paragraph explaining how it was built without copying anything.