A. B. Khan

What Regulated Enterprises Can't Ignore

The Mesh Series · Article 1

mTLSKubernetesIstioMicrosoft Entra IDAmbient meshService meshLGTM stackOAuth 2.0 & OIDC

Cover: What Regulated Enterprises Can't Ignore

Article 1 of a series on Kubernetes, Istio, C#/.NET, and Microsoft Entra ID — for architects who have to make this work, and then defend it in an audit.

You're moving your web apps to Kubernetes. The kind of apps that ran happily on Windows servers for years. Back there, authentication was almost free. They sat inside the domain, Windows-integrated auth did the quiet work, LDAP answered "who is this and what can they do," and nobody thought about it much.

Then you containerize it. The free lunch is over.

Kubernetes doesn't know about your domain. A Linux container has no Windows-integrated anything. So the reflex kicks in: make each service talk to LDAP itself — bind, search, map groups to roles, repeat. It works on the first service. By the third, every service has its own auth code, its own claims mapping, its own private definition of a "role," and its own quiet bugs. The same question — "who is this person, what are they allowed to do" — answered slightly differently in every service.

That's not a microservice architecture. That's a distributed monolith held together with auth tokens and prayer.

Code: before
Diagram: diagram before after

Nobody designs it this way. It accretes. And here's the part that bites later: none of it is visible from the outside. You can't point at one place and say "this is how identity works." It passes every demo. It's what you'll be sweating the week before the audit.

That gap — between "it works in the demo" and "it survives an audit" — is what this whole series is about. Call it the demo-to-audit gap. Most cloud content lives on the demo side. Regulated institutions live on the other one.

The four questions, drawn once

Strip away the tooling and every request into a regulated system has to answer four questions before it touches data. Not "should" — has to, because someone will eventually ask you to prove each one.

Who is the user? Is the workload making this call allowed to make it, and is the call encrypted end to end? Is this the least privilege that gets the job done? And — the one everyone forgets until the auditor arrives — can you prove all of the above actually happened, six months later, without editing a log?

The instinct is to answer those four questions in application code. That instinct is exactly how you end up with an LDAP client in every service. Identity, encryption, authorization, and audit are not business logic. They are infrastructure wearing a business-logic costume.

The service mesh is the argument that you should stop pretending otherwise.

Why this bites enterprise institutions harder

A consumer app that fumbles this ships a bug. A regulated institution that fumbles this fails an examination — and the clocks are unforgiving.

In India, CERT-In's directions give you six hours from noticing a cyber incident to report it, with logs retained 180 days inside the country. Six hours is not a lot of time to reconstruct who called what if your audit trail is a dozen inconsistent log formats. Stack the DPDP Act's breach-notification duty on top, the RBI IT Framework's tier-wise obligations, payment-data localization — and "we'll add proper logging later" stops being technical debt and becomes a regulatory one.

The Middle East tells the same story in a different accent. Saudi Arabia's SAMA Cyber Security Framework grades you on a maturity model — you don't pass once, you prove controls operate continuously. Add NCA's controls and in-Kingdom data residency; in the UAE, CBUAE expectations and the DIFC and ADGM data-protection regimes, each with their own breach-notification duties. Different regulators, same demand: prove it, continuously, and don't let the data leave the country to do so.

The uncomfortable truth: in this world you are not just securing the system. You are on a clock to prove what it did. Having mTLS and proving mTLS to an auditor are two different jobs, and only one of them shows up in the architecture diagram.

How the pieces actually come together

Diagram: diagram two planes

Two identity planes, and the trick is not confusing them.

Entra ID answers "who is the user." End users, OIDC, JWTs, scopes, app roles. This is the human — or the app acting for a human — arriving at your edge.

Istio answers "who is the workload." Pod A talking to Pod B, mutual TLS with certificates issued and rotated automatically, a cryptographic identity per service, and policy about which service may call which. No passwords in config. No service re-implementing anything.

The mesh terminates the user's Entra token at the ingress gateway, enforces mTLS and authorization between every hop, and emits a uniform telemetry stream for all of it. Your service goes back to reading a validated principal and getting on with the business logic it was actually written for. Identity, encryption, and the audit trail move down, into the platform, implemented once instead of a dozen times.

That's the whole pitch. Not "meshes are cool." Answer the four questions once, in infrastructure, consistently, with evidence — instead of N times, in application code, inconsistently, with hope.

The rebuttal I keep getting

"Fine, but if Entra ID goes down, you're just as stuck as when LDAP fell over. You've just moved the single point of failure."

It's a fair hit, and I won't wave it away. Centralizing identity does concentrate risk. But the two failures are not the same animal.

LDAP-in-every-service was a correctness failure, spread thin. A dozen implementations meant a dozen chances to authorize someone who shouldn't be — and the failure was invisible until it wasn't. An Entra outage is an availability failure at a single, well-understood boundary. Availability is the kind of problem infrastructure engineers are actually good at: token lifetimes and caching so a blip doesn't instantly lock the doors, mesh-level mTLS that keeps working service-to-service even when the user-identity provider is unreachable, sensible degraded modes, HA on the pieces you run yourself.

Concentrated-but-engineerable beats distributed-and-unknowable. I would rather defend one identity boundary I can reason about than a dozen I can't. That's not a religious position — it's just the trade I'd make, and I'll show the failure modes as we go so you can make your own.

The alternatives, honestly

A mesh is not the only answer, and it is not free.

Resilience libraries in-process (Polly and friends). No mesh, no sidecar, mTLS and retries as code. Genuinely simpler for a handful of services. It's also how you get back to logic-smeared-everywhere the moment the fleet grows. Pick it when you have three services and no auditor.

Linkerd. Lighter than Istio, less to operate, deliberately fewer knobs. If you don't need Istio's authorization-policy and traffic-management surface, Linkerd will make your life quieter. Pick it when policy expressiveness isn't the point.

Cilium's eBPF mesh / Istio ambient mode. The sidecar-per-pod tax is real — I'll die on that hill later in this series — and the sidecarless approaches are the industry's answer to it. Worth watching hard; worth migrating to deliberately, not on day one.

The mesh earns its complexity when you have many services, real compliance pressure, and a need to prove things. If you have none of those, a mesh is a very expensive security guard for a building with nothing in it.

Security · Audit · Integration — the through-line for this series

The vocabulary we'll build — a glossary, and a teaser

You don't need all of this today. It's the map of where we're going. Skim it now; each line gets its own article as the series unfolds.

The platform

Kubernetes (K8s): the system that runs your containers and keeps them running. The "where."Pod: the smallest thing Kubernetes schedules — one or more containers that live and die together.Control plane: the brain that decides what runs where. You talk to it; you rarely touch it.

The mesh

Service mesh: infrastructure that handles service-to-service traffic — encryption, identity, routing, retries — so your code doesn't.Istio: the mesh this series uses. Powerful, opinionated, occasionally too clever for its own good.Envoy: the proxy doing the actual work. Istio configures it; Envoy moves the packets.Sidecar: an Envoy injected next to every pod. The classic model — and the source of the "tax" we'll argue about.Ambient mode / ztunnel / waypoint: the sidecarless direction. ztunnel does L4 mTLS cheaply; a waypoint proxy handles L7 when you need it. Where this series lands.Gateway API: the modern, standard way to define edge/ingress traffic — the front door.

Identity

OAuth2 / OIDC: the protocols for "prove who you are" and "here's what you may do." OIDC is the login layer on top of OAuth2.JWT: the signed token that carries identity and claims across the wire. Verify it — never just trust it.Microsoft Entra ID: the identity provider for your users and apps. (Formerly Azure AD.)Scopes vs app roles: two ways Entra says "allowed to do X." We'll map both onto mesh policy.Workload identity / federation: how a pod proves who it is to Azure with no secret in config. The workload half of passwordless.Passwordless: killing the credential — passkeys / FIDO2 / Windows Hello / certificate-based auth for people, federation + mTLS for machines.mTLS + SPIFFE/SVID: mutual TLS where every workload carries a cryptographic identity. Encryption and identity in one handshake.

The guardrails

Zero trust / default-deny: nothing is allowed until you allow it. The opposite of "flat network, hope for the best."PeerAuthentication / RequestAuthentication / AuthorizationPolicy: Istio's three levers — is the workload mutually authenticated, is the user's token valid, is this call permitted.NetworkPolicy: Kubernetes-native L3/L4 firewalling. Belt to the mesh's suspenders.OPA Gatekeeper / Kyverno: admission control that refuses to let non-compliant config into the cluster in the first place.

The proof

Telemetry / OpenTelemetry: the signals — logs, metrics, traces — your system emits about itself.LGTM stack: Loki, Grafana, Tempo, Mimir — logs, dashboards, traces, metrics. The evidence machine.Signed evidence / cosign / in-toto: tamper-evident proof that what you claim happened actually happened. The demo-to-audit gap, closed.Drift / compliance posture: the distance between what you declared and what's actually running, watched continuously.

The rules

PCI-DSS 4.0: the card-data security standard. Global, unavoidable the moment you touch payments.RBI IT Framework / CERT-In / DPDP (India): the tier-wise IT rules, the six-hour incident clock, and the data-protection law.SAMA CSF / NCA ECC / PDPL (Saudi), CBUAE / DIFC / ADGM (UAE): the Middle East equivalents — with a maturity model and data-residency teeth.ISO 27001: the international control catalogue everyone maps back to.

That's the series in one screen. Each line is a promise we'll pay off.

figure 04

From here to the standard

Start small. One service, one namespace, mTLS on, a default-deny policy, access logs flowing. That's a weekend. The "industry standard" version — full framework mapping, signed evidence packs, drift detection, an ambient data plane, no passwords anywhere — is where this series lands over the coming months. We climb there one concept at a time, and every rung has real config you can run.

Next up: Kubernetes in five boxes — the only mental model you need before any of this makes sense.

Follow along if you're building regulated workloads on Kubernetes. Twice a week.

Key skills & topics in this article

mTLSKubernetesIstioMicrosoft Entra IDAmbient meshService meshLGTM stackOAuth 2.0 & OIDC

  • #ServiceMesh
  • #Istio
  • #Azure
  • #dotnet
  • #ZeroTrust
  • #Kubernetes

Also on LinkedIn.