Appearance

Service meshes and platform boundaries

Place service identity, traffic control, and provider responsibility precisely.

What you will understand

  • Explain mesh data-plane and control-plane responsibilities.
  • Distinguish mesh mTLS from network reachability policy.
  • Assign managed-provider and application-owner operational duties.

Builds on: Protecting Secrets and tenant boundaries, Tenancy and software supply chains

Mental model: a mesh introduces another control and data path

A service mesh commonly adds a data plane that handles application traffic and a control plane that distributes configuration and identity material. Deployment modes differ: sidecar proxies place a proxy beside a workload, while ambient or node-oriented designs move some functions elsewhere. Avoid assuming every mesh always injects a sidecar or that every request necessarily crosses the same proxy path. Choose the implementation and mode before reasoning about coverage, resources or failure behavior.

Mesh mTLS can authenticate workload peers and encrypt covered connections. Authorization policy can then evaluate service identity and request attributes supported by that data path. This protects a particular communication boundary. It does not authenticate an application’s end user automatically, make the application correct, or ensure every cluster connection is covered. Plaintext exclusions, workloads outside the mesh and external dependencies need explicit handling and observation.

A mesh secures a defined traffic path

The destination still needs appropriate business and end-user authorization; peer identity alone is insufficient.

Flow viewStep 1 of 3
Define covered trafficThe chosen mesh mode determines which connections enter its data plane.. Application A, Source workload, idle. Mesh data plane A, Identity and traffic handling, active. Mesh data plane B, Peer policy and encryption, idle. Application B, Destination workload, idle. Mesh control plane, Identity + config distribution, idleApplication A: Source workload
Application ASource workloadContext
Mesh data plane A: Identity and traffic handling
Mesh data plane AIdentity and traffic handlingIn focus
Mesh data plane B: Peer policy and encryption
Mesh data plane BPeer policy and encryptionContext
Application B: Destination workload
Application BDestination workloadContext
Mesh control plane: Identity + config distribution
Mesh control planeIdentity + config distributionContext
Application ASource workloadContext
Mesh data plane AIdentity and traffic handlingIn focus
Mesh data plane BPeer policy and encryptionContext
Application BDestination workloadContext
Mesh control planeIdentity + config distributionContext
Animation controls
Speed
0.5×
1×
2×
Explore a scenario
Normal behavior
Caller outside coverage
Define covered traffic

The chosen mesh mode determines which connections enter its data plane.

Read the complete visual sequence
  1. Define covered traffic

    The chosen mesh mode determines which connections enter its data plane.

  2. Authenticate peers

    Configured mTLS verifies workload identities and encrypts the covered connection.

  3. Keep application decisions

    The destination still needs appropriate business and end-user authorization; peer identity alone is insufficient.

Caller outside coverage

Traffic outside the configured data path does not automatically gain mesh guarantees.

  1. Unmeshed caller connects

    The caller has no configured mesh identity path.

  2. Policy determines acceptance

    Strict or permissive destination settings affect whether this call is rejected or accepted without the expected protection.

  3. Test coverage explicitly

    Observe this path rather than claiming all cluster traffic is encrypted by installing a mesh control plane.

About this model

Generic data-plane boxes apply across sidecar and other modes; actual placement and supported policy features vary.

Walkthrough: traffic features change application failure behavior

A mesh can provide routing, retries, timeouts, telemetry and access policy, depending on its implementation. Retries can improve transient-failure handling for safe operations, but can multiply load or duplicate side effects for non-idempotent requests. Configure retry budgets, deadlines and application semantics together. A retry at the client, another at the proxy and another in an upstream service can amplify an outage even when each team believes it configured only a small retry count.

NetworkPolicy remains a separate reachability boundary enforced by the networking implementation. A mesh does not replace it. NetworkPolicy can constrain which selected Pods or addresses connect at the supported network layers; mesh policy can add identity and application-aware decisions on covered traffic. Their interactions depend on proxy placement and networking behavior. Test the exact mode, including DNS, control-plane communication, metrics and external egress, rather than assuming one broad deny rule is always compatible with mesh operation.

Network policy, mesh policy, and provider ownership differ

The managed-provider contract and platform ownership map determine who maintains infrastructure, add-ons and data recovery.

Policy viewStep 1 of 3
Constrain connectivityThe networking implementation enforces selected reachability rules independently of mesh identity policy.. NetworkPolicy, Reachability enforcement, active. Mesh policy, Covered service identity / L7, idle. Application policy, Business and user authorization, idle. Managed provider, Contracted infrastructure duties, idle. Platform / app team, Workloads, data and add-ons, idleNetworkPolicy: Reachability enforcement
NetworkPolicyReachability enforcementIn focus
Mesh policy: Covered service identity / L7
Mesh policyCovered service identity / L7Context
Application policy: Business and user authorization
Application policyBusiness and user authorizationContext
Managed provider: Contracted infrastructure duties
Managed providerContracted infrastructure dutiesContext
Platform / app team: Workloads, data and add-ons
Platform / app teamWorkloads, data and add-onsContext
NetworkPolicyReachability enforcementIn focus
Mesh policyCovered service identity / L7Context
Application policyBusiness and user authorizationContext
Managed providerContracted infrastructure dutiesContext
Platform / app teamWorkloads, data and add-onsContext
Animation controls
Speed
0.5×
1×
2×
Explore a scenario
Normal behavior
Assume the provider owns every recovery
Constrain connectivity

The networking implementation enforces selected reachability rules independently of mesh identity policy.

Read the complete visual sequence
  1. Constrain connectivity

    The networking implementation enforces selected reachability rules independently of mesh identity policy.

  2. Evaluate identity and request

    The mesh can add identity-aware or L7 decisions where supported; application authorization remains necessary.

  3. Assign operations explicitly

    The managed-provider contract and platform ownership map determine who maintains infrastructure, add-ons and data recovery.

Assume the provider owns every recovery

A control-plane service does not imply automatic application-data restoration.

  1. Cluster is managed

    The provider operates specified infrastructure components.

  2. Application data is lost

    A workload or external database still requires its own backup and restore owner.

  3. Responsibility gap is exposed

    Without an explicit ownership map, neither a mesh nor a managed API restores the missing application records.

About this model

Provider responsibilities must be verified for the actual service; no universal managed-Kubernetes contract is assumed.

This policy selects labeled web Pods for ingress isolation and adds an allow rule for labeled clients on TCP 80 within the same namespace. It is valid without a mesh, but depends on NetworkPolicy enforcement. Existing policies selecting the same Pods are additive, and documented exceptions such as traffic from the Pod’s own node still apply. It is an isolated teaching example, not a complete mesh installation policy.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: m19-web-ingress
  namespace: kv-lab
  labels:
    lab: m19
spec:
  podSelector:
    matchLabels:
      app: m19-web
  policyTypes: [Ingress]
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: m19-client
      ports:
        - protocol: TCP
          port: 80
kubectl --context kind-kv-lab -n kv-lab get networkpolicies
kubectl --context kind-kv-lab -n kv-lab get pods -o wide
# Add-on discovery is read-only; absence is an expected local outcome.
kubectl --context kind-kv-lab get crd -o name
kubectl --context kind-kv-lab get namespaces

Practice: write an ownership map before installing an add-on

Use the m19 local exercise for a controlled declaration-and-drift experiment. No mesh is required. For a mesh evaluation, first identify the intended covered workloads, trust root, certificate rotation owner, policy author, telemetry destination and upgrade owner. Choose an actual mesh mode, then test a permitted call, a denied call, an unmeshed caller and control-plane interruption. Observe established versus new connections according to the implementation rather than promising universal outage behavior.

Now consider a managed Kubernetes service. The provider may operate control-plane hosts and storage while the customer still owns workload images, RBAC grants, namespaces, application data, add-ons and much of network policy. The exact boundary depends on the service and configuration. A provider’s control-plane backup does not automatically become a customer-accessible application restore procedure. Document responsibilities using that provider’s current contract before assuming that a platform team or cloud vendor will rotate a particular certificate or recover a database.

Pitfalls: extra machinery has costs and blind spots

Proxies and agents consume resources, add configuration and change debugging paths. An application can fail because of DNS, service selection, missing endpoints, mesh policy, certificate validity, routing configuration or the application itself. Start with evidence at each boundary instead of treating every connection failure as a mesh bug. Encryption in transit does not protect plaintext logs or credentials exposed through overly broad Kubernetes permissions.

A shared platform should offer a small, documented interface with explicit defaults and escape routes. If teams must understand every internal mesh resource to deploy a simple service, the abstraction may be leaking operational complexity. Still preserve enough diagnostics for users to identify which owner needs to act. A managed service reduces some ownership, but it does not remove the need for application-level recovery drills.

Check your understanding

Mesh mTLS is enabled. Can NetworkPolicy and application authorization be removed?

No. mTLS supplies peer authentication and encryption for covered traffic. Network reachability and application or user authorization are separate decisions, and coverage depends on the mesh implementation and mode. Keep and test each required boundary.

Next, combine these layers in three recovery capstones. Each investigation starts with a specific failure and ends with observable recovery evidence rather than a claim that every platform layer was validated.

Go to the source

Reviewed 2026-10-27 · Kubernetes 1.37 · Related local exercise

Search the book

Search loads when you open it.