A. B. Khan

What a Service Mesh Actually Does (and What It Doesn't)

The Mesh Series · Article 4

IstioService meshmTLS.NET & C#

Cover: What a Service Mesh Actually Does (and What It Doesn't)

Article 4 · 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.

A service mesh is a layer of proxies. That's the whole idea, stripped of the conference-stage mystique. Next to every pod, you run a second container — an Envoy proxy, the "sidecar" — and you route all of that pod's traffic through it. Your service still thinks it's calling accounts-api directly. It isn't. It's talking to its local proxy, which talks to the remote proxy, which talks to accounts-api. Two hops you didn't write, doing work you used to write by hand.

That work is the point. Mutual TLS on every call. Retries when a downstream flaps. Timeouts so a slow dependency doesn't cascade into a thread-pool stall. Routing rules for canaries and blue-green. And a telemetry stream off every single hop. The mesh takes over service-to-service traffic so your application code stops carrying it.

Illustration

Why a regulated shop tolerates this

For a bank or an NBFC, the appeal isn't the retries. You could get retries from a library. The appeal is uniformity.

Without a mesh, every team implements mTLS, logging, and resilience their way. The payments service uses one TLS config and ships structured JSON logs. The customer-data API trusts a shared cert from 2022 and logs plain text to stdout when someone remembers. The notification service does neither. When an auditor asks "prove every service-to-service call inside this cluster is encrypted, and show me the log," you're stitching together six half-truths across four teams.

A mesh collapses that. mTLS is on for every hop, configured once, enforced by proxies that the application teams don't even touch. Telemetry comes off every proxy in the same shape — same fields, same labels, same place. That is the raw material for the demo-to-audit gap: the distance between a system that works in the demo and a system that can prove how it worked, six months later, to someone hostile. A mesh doesn't close that gap by itself. But it gives you one encryption story and one telemetry story instead of a dozen bespoke ones, which is most of the fight.

Under CERT-In, you have six hours to report an incident and 180 days of logs to keep, in-country. Under RBI's IT Framework, you're demonstrating access control and data localization on payment flows. Under SAMA's CSF — a maturity model — you're not proving a control exists once; you're proving it runs continuously. A uniform, mesh-wide audit stream is how you answer all three without a forensics project each time someone asks.

How the pieces fit: data plane vs. control plane

This is the split that matters, and the one most explanations blur.

The data plane is the proxies. The fleet of Envoy sidecars actually moving packets, terminating TLS, enforcing timeouts, counting requests. When a call is encrypted or retried, a data-plane proxy did it. The data plane is on the request path — every millisecond it spends is a millisecond your user waits.

The control plane is istiod. One component (in Istio's case) that watches the Kubernetes API, reads your declarative config, and pushes the resulting instructions down to every proxy. It configures the data plane; it does not touch your traffic. If istiod goes down for a few minutes, existing proxies keep running on their last-known config — your requests still flow. You just can't change anything until it's back.

Hold that distinction. Data plane moves the packets. Control plane programs the movers. Every Istio object you'll ever write — PeerAuthentication, AuthorizationPolicy, VirtualService — is you talking to the control plane, which translates your intent into proxy config. You never configure a proxy directly. You declare what you want; istiod makes 200 proxies agree.

Show the config: resilience as configuration, not code

Here's the shift made concrete. Retries and timeouts stop being something you write in C# — HttpClient handlers, Polly policies, retry counters — and become something you declare.

Code: vs

Read what that buys you. Any call to accounts-api gives up after 2 seconds total. Each attempt gets 1 second, retried up to 3 times, but only on 5xx responses or a failure to connect — not on a 400, because retrying a bad request is just a bad request repeated. None of this lives in your service. A .NET team and a Java team and a Go team calling accounts-api all get identical resilience behavior, because it's enforced at the proxy, not re-implemented per language.

That last point is the quiet win for a polyglot enterprise. Resilience becomes a property of the platform, reviewable in Git, uniform across stacks — instead of an implementation detail that drifts per team.

Security · Audit · Integration

What a mesh is not — the half the title promises

The pitch oversells. Here's where a mesh stops.

It is not an API gateway. The gateway sits at the edge — north-south traffic, from outside the cluster in. It does auth for external callers, rate limiting, request transformation, exposing your API to the world. A mesh governs east-west traffic — service to service, inside the cluster. Different job, different tier. Istio ships an ingress gateway too, but that's a gateway wearing Istio's clothes; it isn't the mesh. Confusing the two is how people end up trying to do public API management with AuthorizationPolicy and hating their life.

It is not your application's business authorization. The mesh can assert service A is allowed to call service B. It cannot assert this teller may approve this transaction up to ₹50,000 but not ₹50,001. Identity and coarse service-to-service policy, yes. Business rules that depend on who the user is and what they're doing — no. That's your app, your Entra ID claims, your domain logic. A mesh that thinks it does business authz is a mesh that has quietly moved your rules into YAML where your domain experts can't read them.

It is not a fix for bad code. Retries paper over a flaky dependency; they do not fix the dependency. A mesh will happily retry your N+1 query three times and log all three beautifully. Latency you designed in is latency the mesh faithfully measures and forwards. It is an operational layer, not an absolution.

It is not free. Every sidecar is another container — CPU, memory, a process to patch, a proxy to upgrade in lockstep with the control plane. Every hop now goes through two extra proxies, adding real latency to the request path. Multiply by every pod in the cluster. That's the sidecar tax: a per-pod resource and latency cost, plus the operational weight of running a proxy fleet, that you pay whether or not those particular services needed a mesh.

Which is the contrarian bit worth saying plainly. Nobody got fired for adding a sidecar. They just got paged. Meshes get adopted too early — three services that talked fine over plain HTTP, now wrapped in a control plane, a proxy fleet, and a new class of 3 a.m. incidents where the mesh is the outage. The tax is defensible at 40 services with an auditor at the door. It is theater at three services with none.

The sidecar tax is also exactly why this series later moves to ambient mode — Istio's newer, sidecar-less data plane that pushes mTLS and telemetry into a per-node component and drops the per-pod proxy for L4. Same uniformity, different cost curve. We'll get there.

Alternatives — pick this instead when…

You have a mesh problem. You do not necessarily have an Istio problem.

Linkerd — lighter, opinionated, far fewer knobs. Its data plane is a purpose-built Rust micro-proxy, not general-purpose Envoy, so the tax is smaller and the operational surface is calmer. Pick this instead when you want mTLS and solid telemetry across every hop but you don't need Istio's deep policy surface — no complex L7 authorization, no elaborate traffic-splitting DSL. Most teams that "chose Istio" needed Linkerd.Cilium's eBPF / ambient approaches — enforcement in the kernel via eBPF, or a sidecar-less mesh, so identity and encryption happen without a proxy next to every pod. Pick this instead when the sidecar tax itself is the dealbreaker — latency-sensitive workloads, dense clusters where per-pod proxies hurt, or teams that will not accept the per-hop overhead.In-process resilience libraries like Polly — retries, timeouts, circuit breakers compiled into your .NET service. Zero proxies, zero control plane. Pick this instead when you're at small scale, one or two stacks, and no auditor is asking you to prove uniform mTLS across the cluster. The moment you're polyglot or regulated, the per-service drift Polly can't prevent becomes the problem the mesh exists to solve.

The honest read: a mesh earns its tax when you have enough services that uniformity is worth more than simplicity, and enough regulatory pressure that a single audit stream beats a code library. Below that line, you're buying a control plane to feel enterprise. Above it, you're buying the only thing that scales.

From simple to standard

Start where it's cheap. Two services, a shared cert, retries in Polly, structured logs — fine. Nobody's auditing three pods.

The mesh becomes the standard the day the honest answer to "prove every internal call is encrypted and show me the evidence" stops being a sentence and starts being a migration project. That's when uniform mTLS and one telemetry stream — enforced below your code, identical across every stack — go from nice to non-negotiable. You adopt the mesh not because it's elegant, but because the alternative is defending a dozen bespoke setups to someone who is paid to find the gap.

Next up — Article 5, Istio without the overwhelm: the four objects that do 90% of the work, and the two dozen you can ignore until someone makes you care.

Key skills & topics in this article

IstioService meshmTLS.NET & C#

  • #Kubernetes
  • #dotnet
  • #Azure
  • #Istio
  • #CloudNative
  • #AKS

Also on LinkedIn.