The integration thesis — Entra for users, Istio for workloads
The Mesh Series · Article 10
Microsoft Entra IDWorkload identityIstioJWT validationmTLSSPIFFEOAuth 2.0 & OIDC

The Mesh Series · Article 10 · Identity done right
Article 9 left a question on the table: if Entra is now the enforcement point for every human and the mesh is the enforcement point for every workload, how do the two fit into one system — and where does each one's authority stop?
Here's the whole answer, and it's smaller than people expect. Entra knows who. The mesh knows what. A user proves they are a person; a workload proves it is a service. Those are different questions, answered by different machinery, and the single most common architecture mistake in this space is asking one system to answer both.

Two planes. The user plane runs north-south: a person signs in to Entra, gets a token, and that token rides inbound to the edge of your cluster. The workload plane runs east-west: services prove themselves to each other over mTLS using the SPIFFE identities from Article 8. They are not the same system wearing two hats. They are two systems that meet at exactly one seam — and the integration thesis is about designing that seam deliberately instead of letting it blur.
Why regulated enterprises should care
Collapse the two planes into one and you lose the ability to answer either question cleanly. That sounds abstract until an auditor is in the room, so make it concrete.
An incident review asks two things, always. Which user initiated this? and which service actually touched the data? They are different questions with different answers. The user might be a branch operator authenticated with a passkey; the service might be a reconciliation job running under its own workload identity, three hops removed from that operator. Under CERT-In's six-hour clock in India, or a SAMA maturity assessment in the Gulf, "a request happened and it was authorised" is not sufficient. You need to name the human and name the workload, separately, because they are separately accountable.
Now watch what happens when you take a shortcut. Wire your services to call each other with a shared Entra client secret, and every service-to-service hop authenticates as the app registration, not as itself — you have erased the "which service" answer, and reintroduced the credential-sprawl the whole series is trying to kill. Or push user tokens deep into your service graph and validate them at every hop, and now a leaked internal service can replay a user's token laterally — you have erased the boundary that kept user authority at the edge. Both shortcuts feel like simplification. Both destroy an answer you are legally required to produce.
The two-plane model isn't architectural fastidiousness. It's what keeps the two proofs the regulator asks for actually provable.
How the pieces come together — the seam
The seam has exactly one location and one job: the ingress gateway. This is where the user plane terminates and the workload plane takes over.
A request from a person arrives at the gateway carrying an Entra JWT. The gateway validates it — issuer, audience, signature, expiry — and this is the only place user-token validation has to happen at full strength. That's Article 11's job, so we won't build it here. What matters for the thesis is what happens next: past the gateway, the request travels east-west on the workload plane, over mTLS, between SPIFFE-identified services. The user's identity doesn't vanish — it rides along as request context, propagated as a verified principal — but the transport is now secured by workload identity, not by the user's bearer token.
So inside the mesh, every call has two identities attached at once: the workload that made the call (from mTLS) and the user on whose behalf it's being made (from the propagated token). Istio models these as two distinct things. PeerAuthentication governs the workload plane; its identity field is principals — the SPIFFE identity. RequestAuthentication governs the user plane; its identity field is requestPrincipals — the JWT's issuer and subject. Two CRDs, two fields, two planes. And you can require both in a single authorization decision.
Show the config
Three objects. The first secures the workload plane, the second validates the user plane, the third composes them.

Now the seam, in one policy. To touch the ledger, the caller must be the payment service as a workload and be acting for a real signed-in user — not one or the other:

Read that from.source block slowly, because it is the entire article compressed into eight lines. principals is the workload; requestPrincipals is the user; requiring both in one rule means a stolen user token is useless without also being the right workload, and a compromised workload is useless without also carrying a valid user. Two planes, composed — not merged.
Your C# barely changes. The service runs under its workload identity (Article 8) and reads the user from the validated token — the two identities live side by side in one request, exactly as the mesh sees them:
// workload identity is ambient (DefaultAzureCredential, Art. 8);// the USER arrives as validated claims — the mesh already checked the tokenvar user = User.FindFirst("oid")?.Value; // the human this service is acting for
Security · Audit · Integration
Security property gained. Defense that composes. An attacker now needs to defeat both planes to move — a phished user token can't traverse the service graph without a valid workload identity, and a popped container can't act on data without a real user principal. Neither plane is a single point of compromise.
Audit evidence produced. You can answer both of the auditor's questions from the same request, separately: the workload principal (a named SPIFFE identity) and the user principal (a named Entra subject with an oid). "Service X, acting for user Y, wrote to the ledger at time Z" — two accountable identities, one log line, exactly what CERT-In and SAMA want to see.
How it integrates. This is the backbone the rest of Part B hangs on. Terminating the user token at the edge is Article 11. Validating it deeply in C# is Article 12. Doing both mesh-side and in-code — defense in depth — is Article 13. mTLS and SPIFFE, the workload plane's plumbing, is Article 14. Every one of those is filling in one of these two planes; none of them merges them.
Alternatives, and when you'd actually pick them
The two-plane model is the default. The honest variations are mostly about where the user plane terminates and how much you make the mesh do.
Terminate user identity at the app, not the mesh. Skip RequestAuthentication and validate the Entra JWT only inside each service with Microsoft.Identity.Web. Fine for a single service or a team that doesn't run a mesh yet — the identity library is mature and you own the logic. The cost shows up at scale: every service reimplements validation, and you've lost the one central place to prove "all inbound user auth is enforced." The mesh earns its keep precisely when there are enough services that per-service validation becomes per-service drift.
oauth2-proxy or API Management at the edge. A dedicated proxy (oauth2-proxy is the common secretless-Entra pattern on AKS; API Management is the managed option) can terminate the OIDC flow before traffic reaches the gateway. Reasonable when you want the login dance, session cookies, and token refresh handled outside your services — but it's another component on the user plane, and it doesn't change the thesis. The workload plane is still the mesh's job.
The one-plane temptations — name them. "Just use Entra for everything" collapses the workload plane into shared client secrets and erases the which service answer. "Just use mesh mTLS for everything" collapses the user plane — the mesh has no concept of a passkey, an MFA prompt, or Conditional Access, so it cannot authenticate a human. Both sound like simplification and both are category errors: they delete a proof you can't afford to lose. A unified identity plane is not architecture. It's usually a shortcut wearing architecture's clothes.
From the toy to the standard
The toy is two CRDs and one composed policy on a single namespace. The industry-standard version is the same shape everywhere: user identity terminated once at the edge and carried inward as verified context, workload identity enforced on every east-west hop, and authorization policies that name both a workload principal and a user principal wherever the data is sensitive enough to demand it. Two planes, one seam, no merges — and every access resolves to two accountable identities instead of a fog.
That seam is where the next article lives. We've said the ingress gateway is where the user plane terminates; now we build it — the Entra OIDC flow landing on an Istio gateway, the token validated at the door, the user handed inward as a principal the mesh understands.
That's Article 11: terminating user identity at the mesh edge.
Next in the series — Article 11: Terminating user identity at the mesh edge.
Key skills & topics in this article
Microsoft Entra IDWorkload identityIstioJWT validationmTLSSPIFFEOAuth 2.0 & OIDC
Also on LinkedIn.