Join our Newsletter — 33% off our NHI Course
Home› Guides› NIST SP 800-207A Zero Trust for Cloud-Native Applications…
Guide Zero Trust

NIST SP 800-207A Zero Trust for Cloud-Native Applications Guide: Identity-Based Segmentation in Practice

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 27 October 2026 13 min read
On this page

In cloud-native estates, IP addresses change by the minute and pods share nodes, so access rules written against subnets cannot say which service may call which API. NIST SP 800-207A, A Zero Trust Architecture Model for Access Control in Cloud-Native Applications in Multi-Cloud Environments (final, September 2023), answers this by adding identity-tier policies, based on cryptographic service and user identities enforced by proxies, on top of the network-tier rules that remain. It is the practical companion to SP 800-207 for microservices running across clusters, clouds and on-premises sites. This guide is for platform, security and identity engineers who need to turn 800-207A into mesh policies, workload identity and monitoring. The general zero trust model is covered in the NIST SP 800-207 Zero Trust Architecture Guide; this page goes into 207A itself.

Key takeaways

  • Two policy tiers, not one. 800-207A keeps network-tier rules (relatively static, port and gateway based) and adds identity-tier rules (dynamic, expressed as service identities, verbs and paths), and argues the combination beats either alone.
  • Five identity-based segmentation requirements. ID-SEG-REC-1 to 5 cover encryption in transit, short-lived service credentials, service-to-service authorisation, phishing-resistant end-user authentication and per-request end-user authorisation.
  • The service mesh is the policy machinery. The mesh control plane acts as the policy administration point, and ingress, sidecar and egress proxies act as policy enforcement points.
  • Workload identity is SPIFFE-shaped. Each workload gets a SPIFFE ID in an SVID, usually an X.509 certificate, used for mutual TLS; connections are kept short-lived, roughly matching certificate lifetime.
  • Monitoring is part of the model. MON-CNA-REQ-1 to 4 and MON-DATA-USE-1 to 2 require telemetry for every request and its service-call chain, fed back into access decisions.

What it is and who it applies to

SP 800-207A was published as final in September 2023 (draft April 2023), written by Ramaswamy Chandramouli of NIST and Zack Butcher of Tetrate. It is a guidance document, not a control catalogue: it describes an architecture and a policy framework and gives numbered recommendations rather than SHALL statements. It applies wherever microservices run as containers on an orchestration platform with a service mesh, on premises or across several clouds.

  • Audience: security architects, platform teams running Kubernetes and service meshes, and DevSecOps teams writing policy as code.
  • Builds on: SP 800-207 (Zero Trust Architecture), SP 800-204A (security services for microservices using a service mesh) and SP 800-204B (attribute-based access control for microservices using a service mesh).
  • Out of scope: sidecar-less mesh designs, and application-tier policies such as web application firewall rules, payload validation and request-semantics checks with tools like Open Policy Agent. Those still matter, but the document does not specify them.
  • Not a compliance mandate: nothing in 800-207A is required by law, but US federal zero trust programmes and many private architectures use it as the reference for east-west controls in cloud-native systems.

Structure and key requirements

Document layout

SectionContent
1Introduction, relation to other NIST guidance, scope
2The enterprise cloud-native platform and its components: global control plane, management plane, proxy types
3Designing the policy framework: functional components of identity-based segmentation (ID-SEG-REC-1 to 5), its shortcomings, multi-tier policies
4Implementing multi-tier policies: reference scenario, role of the mesh, policy deployment, a DMZ and three-tier scenario, comparison of identity-tier and network-tier policies, monitoring framework
5Summary and conclusions

Platform components mapped to zero trust roles

800-207A componentZero trust role (SP 800-207 terms)What it does
Mesh control plane (per cluster)Policy administration pointDistributes identities, configuration and policy to proxies
Underlying policy toolsPolicy decision pointEvaluate identity-tier rules, or call an external authorisation service
Ingress proxyPolicy enforcement pointTraffic entering the cluster
Sidecar proxyPolicy enforcement pointTraffic between services inside the cluster
Egress proxyPolicy enforcement pointTraffic leaving the cluster
Global control planeEnterprise policy and identity authorityIssues identities enterprise-wide (for example from an enterprise PKI) and can shut down a compromised cluster's control plane
Management planeAdministration interfaceHuman interfaces for defining policy and viewing telemetry
Edge gatewayEnforcement at the edgeTerminates external traffic and load balances per request across clusters and sites
Transit gatewayEnforcement between sitesA paired egress and ingress proxy plus the firewall rules connecting them

The document cites Envoy as an example data plane that can act both as sidecar and as transit gateway.

Identity-based segmentation requirements (Section 3.1)

IDRequirementTypical implementation
ID-SEG-REC-1Encrypt all communication between service endpoints, wherever they runMesh-wide mutual TLS in strict mode; no plaintext fallback
ID-SEG-REC-2Services present short-lived, cryptographically verifiable identity credentials, authenticated per connection and re-authenticated regularlySPIFFE X.509 SVIDs with lifetimes of hours, rotated automatically
ID-SEG-REC-3Service-to-service authorisation uses runtime identity; external authorisation services may be called when proxies are not enoughMesh authorisation policies keyed on SPIFFE ID, method and path; external authorisation for complex decisions
ID-SEG-REC-4End users authenticate through a robust IAM system with phishing-resistant MFA; short-lived user credentials are exchanged for a locally verifiable token checked at each hopOIDC sign-in with passkeys; JWT validated at ingress and sidecars
ID-SEG-REC-5End-user-to-resource authorisation is checked per request, in the application, against token claims, or via an external policy decision pointClaims-based checks at the sidecar; fine-grained decisions in the service or a PDP

Section 3.2 is candid about the limits: identity-based policies depend on a trustworthy identity system and proxies, and on their own they do not stop traffic that never passes through a proxy. That is why Section 3.3 introduces multi-tier policies.

Multi-tier policies

  • Network-tier policies: allowed communication between network elements, such as firewall rules and port restrictions. Coarse-grained rules cover perimeters and gateways; fine-grained rules (microsegmentation) cover east-west paths.
  • Identity-tier policies: the access scope of services and resources based on service and user identities, deployed at the mesh data plane.
  • Worked example (Section 4.3): a firewall rule lets a specific cloud egress gateway subnet reach the on-premises ingress gateway on port 15443, while an identity rule lets only Service 1 call GET on /public on port 443. The firewall rule narrows where traffic can flow; the identity rule decides which workload may do what.
  • The trade (Sections 3.2 and 4.6): keep network-tier rules required for compliance (Section 3.2 notes they cannot be eliminated given requirements such as PCI DSS), relax them where identity-tier controls give better granularity, and avoid relying on either tier alone.

The Network Segmentation Guide covers network-tier design in depth.

Monitoring requirements

  • MON-CNA-REQ-1 to 4: monitoring shall cover all resource categories (enterprise-owned, unmanaged and personal), application and infrastructure elements, every user request together with its chain of service calls, and changes to directories.
  • MON-DATA-USE-1 to 2: behavioural and flow data are used in access decisions, to fine-tune access rights and to trigger step-up authentication.

Identity and NHI requirements

800-207A is, in practice, a non-human identity standard. Every identity-tier rule is about a workload identity, and the model only holds if those identities are short-lived, attested and well governed.

  • SPIFFE IDs and SVIDs: each workload receives a URI such as spiffe://example.org/ns/payments/sa/api, carried in an X.509 SVID (the most common form). Issue SVIDs only after attesting the workload (node and workload attestation in SPIRE, or the mesh's own identity issuance tied to Kubernetes service accounts). See the SPIFFE and SPIRE Guide and the Workload Attestation Guide.
  • Connection and credential lifetime: mTLS authenticates at connection set-up, not per request. 800-207A notes that connections usually last as long as the identity certificate TTL, or as little as 15 to 30 minutes depending on configuration; shorter is better, so that a revoked or expired identity stops working quickly.
  • A universal identity domain: the document recommends consistent service names across environments (citing SP 800-204A). Without it, the same service has different identities in each cluster and policies drift.
  • Kubernetes service accounts are the root: in most meshes the workload identity is derived from the pod's service account. Over-shared or default service accounts collapse identity-tier policy, because many workloads end up with the same SPIFFE ID. See the Kubernetes Service Account Token Guide.
  • User identity through the call chain: ID-SEG-REC-4 expects a locally verifiable token at each hop. Pass the user context with constrained, short-lived tokens rather than forwarding the original bearer token everywhere; see the OAuth Transaction Tokens Guide.
  • Static secrets break the model: a long-lived database password or cloud access key inside a pod lets that workload act outside the mesh's identity controls. Replace them with workload identity federation; see the Workload Identity Federation Guide.

Implementation steps

  1. Establish workload identity first. Decide the trust domain and SPIFFE ID scheme, give every workload its own Kubernetes service account, and make the mesh or SPIRE issue short-lived SVIDs. Connect the mesh certificate authority to an enterprise root held in an HSM or managed CA.
  2. Turn on mTLS in permissive mode, then observe. Most meshes allow plaintext and mTLS at once. Use mesh telemetry to find workloads still sending plaintext and fix them.
  3. Move mTLS to strict, namespace by namespace. In Istio, for example, this is a PeerAuthentication resource with mode STRICT. Start with non-production namespaces, then lower-risk production namespaces. Rollback is switching the namespace back to permissive.
  4. Write identity-tier allow policies from observed traffic. 800-207A describes an observe-and-lock-down approach: use telemetry to see which calls actually happen, then write fine-grained allow rules by source identity, method and path. Apply a default deny per namespace once the allow rules are in place.
  5. Use dry-run where the mesh supports it. Some meshes can evaluate authorisation policies in audit or dry-run mode and log what would have been denied. Run every new policy that way for at least one release cycle.
  6. Add end-user token validation. Validate JWTs at ingress (issuer, audience, signature, expiry) and propagate a constrained token inward; enforce claims checks at sidecars for sensitive services.
  7. Keep and tune network-tier rules. Retain the firewall and Kubernetes NetworkPolicy rules needed for compliance and for traffic that bypasses proxies, and relax only where identity-tier rules now carry the decision.
  8. Manage policy as code. Store mesh policies in version control, review them like application code, test them automatically in CI by exercising the application and checking outcomes, and deploy them through the same pipeline. 800-207A notes that declarative policy as code can run in CI/CD and be tested without exact infrastructure configuration.

Evidence and assessment

Because 800-207A has no SHALL statements, assessments test the outcome of each recommendation. Typical evidence:

RecommendationEvidenceTest
ID-SEG-REC-1Mesh mTLS configuration in strict mode for all namespaces; exceptions registerAttempt a plaintext connection between two pods; it should fail
ID-SEG-REC-2SVID lifetime and rotation settings; CA configurationInspect a live certificate's validity period and SPIFFE ID
ID-SEG-REC-3Authorisation policies per namespace with default denyCall a service from an unauthorised workload; expect a denial logged at the sidecar
ID-SEG-REC-4IdP policy requiring phishing-resistant MFA; ingress JWT validation rulesSend an expired or wrong-audience token; expect rejection
ID-SEG-REC-5Claims-based rules or PDP integration for sensitive endpointsCall with a valid token lacking the required claim
MON-CNA-REQ-3Distributed tracing and access logs linking the user request to each service callTrace one request end to end

Metrics:

  • share of service-to-service traffic (by request volume) on mTLS in strict mode;
  • share of namespaces with default-deny identity-tier policy;
  • number of workloads sharing a service account or SPIFFE ID with another workload;
  • median SVID lifetime and the oldest certificate in use;
  • authorisation denials per day at sidecars, investigated as either policy gaps or attempted lateral movement;
  • pods holding static cloud or database credentials.

Lateral movement inside clusters maps to ATT&CK T1021 Remote Services and T1210 Exploitation of Remote Services, and stolen workload credentials to T1078.004 Cloud Accounts; sidecar denial logs and unexpected identity pairs are the signals to watch.

Mapping to other frameworks

800-207A elementNIST SP 800-53 Rev. 5NIST CSF 2.0CIS Controls v8.1
Encryption between services (REC-1)SC-8PR.DS-023.10 Encrypt Sensitive Data in Transit
Service identity and authentication (REC-2)IA-9, IA-5(2)PR.AA-01, PR.AA-035, 6
Service-to-service authorisation (REC-3)AC-3, AC-4PR.AA-056
End-user authentication (REC-4)IA-2(1), IA-2(2), IA-2(8)PR.AA-036.3, 6.5
Network-tier policiesSC-7, SC-7(5)PR.IR-0112, 13
Monitoring frameworkAU-12, SI-4DE.CM-01, DE.CM-038, 13

For ISO/IEC 27001:2022, the closest Annex A controls are 8.20 (Networks security), 8.22 (Segregation of networks) and 8.5 (Secure authentication). The CISA Zero Trust Maturity Model Guide shows where these controls sit in the Applications and Workloads and Networks pillars.

Common pitfalls

  • Permissive mTLS forever. Teams turn on mTLS in permissive mode for migration and never switch to strict, so plaintext still works and REC-1 is not met.
  • One service account per namespace. When every pod in a namespace shares the default service account, identity-tier rules cannot tell them apart.
  • Allow-all policies written to "unblock" a release. A wildcard source in an authorisation policy silently restores flat trust. Review policies in code review and alert on wildcards.
  • Removing network-tier controls too early. Traffic that does not pass through a proxy (host-network pods, node agents, some managed services) is not covered by identity-tier rules. 800-207A expects both tiers.
  • Forwarding the user's original bearer token to every service. Any compromised service can then replay it elsewhere. Exchange it for constrained, audience-specific tokens.
  • Static credentials alongside the mesh. Exposed Kubernetes secrets with broad access, as in the exposed SAP Kubernetes secrets case, bypass identity-tier controls entirely. See the Kubernetes Secrets Security Guide.

Practitioner checklist

  • Define a trust domain and SPIFFE ID naming scheme that is consistent across clusters and clouds.
  • Give each workload its own service account and attested, short-lived SVID.
  • Enforce strict mTLS in every namespace, with a time-limited exceptions register.
  • Write default-deny identity-tier authorisation policies from observed traffic, tested in dry-run first.
  • Validate end-user JWTs at ingress and propagate constrained tokens inward.
  • Keep network-tier rules for compliance scope and for traffic outside the mesh.
  • Manage mesh policy as code with review, automated tests and pipeline deployment.
  • Trace every user request through its service-call chain and feed denials into detection.
  • Remove static credentials from pods in favour of workload identity federation.

Standards and references

Related NHI Mgmt Group resources: NIST SP 800-207 Zero Trust Architecture Guide · Service Mesh Security Guide · SPIFFE and SPIRE Guide · Zero Trust Identity Guide

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 27 October 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.