CNCF Security Technical Advisory Group (TAG)

Secure the cloud/infrastructure layer (the trusted computing base): provider account security, infrastructure configuration, network controls and the environment hosting clusters, per the 4Cs of Cloud Native Security.

• Cloud provider account/security baseline
• Infrastructure configuration hardening evidence
• Network controls around the cluster environment

• Misconfigured cloud account/infrastructure
• Cluster exposed by the cloud layer

Secure the orchestration/cluster layer: API server access control, RBAC, network policy, component configuration and securing the workloads running in the cluster.

• Cluster RBAC + API server access controls
• Network policy enforcement
• Cluster component hardening

• Over-permissive cluster RBAC
• No network policy

Secure the application code layer: secure coding, dependency management, secrets handling and application-level controls (the layer with the most direct control for the organisation).

• Secure coding standards
• Dependency/SCA management
• Secrets-in-code prevention

• Vulnerable dependencies
• Secrets committed to code

Secure the container layer: image provenance and hardening, runtime privileges, isolation and container configuration.

• Container image hardening + provenance
• Runtime privilege/isolation configuration

• Privileged/unhardened containers
• Untrusted images

Support regulatory audits for cloud-native environments: evidence collection, compliance automation and continuous control monitoring mapped to applicable regimes.

• Compliance evidence collection / automation for cloud-native controls
• Mapping of cloud-native controls to applicable regulations

• Manual/ad-hoc audit evidence
• No control-to-regulation mapping

Address industry-specific compliance obligations (e.g. financial-sector EU regulations) when running cloud-native workloads, mapping sector requirements to cloud-native controls.

• Sector-specific requirement mapping (e.g. financial regulations)
• Evidence of sector controls in the cloud-native estate

• Sector obligations not mapped to cloud-native controls

Verify artifacts and images at deploy time: signature verification, provenance/attestation checks and trusted-registry enforcement.

• Artifact signature verification at deploy
• Trusted-registry allowlist

• Deploying unverified artifacts
• Pulling from untrusted registries

Prepare incident response and mitigation for cloud-native workloads: playbooks, isolation/quarantine capability and rollback.

• Cloud-native incident response playbook
• Workload isolation/quarantine + rollback capability

• No IR plan for cluster workloads

Establish observability for deployed workloads: logging, metrics and tracing to support detection and response.

• Centralised logging/metrics/tracing for workloads
• Security-relevant event collection

• No workload observability
• Security events not collected

Validate workloads at deployment via admission control: verify image provenance/signatures, policy compliance and configuration before admitting to the cluster.

• Admission control policy (e.g. policy-as-code) verifying signatures + config
• Pre-deployment validation records

• No admission control
• Unsigned/unverified images admitted

Integrate security into development: threat-informed requirements, IDE/security-plugin checks, secret detection and security gates so issues are found early in the Develop phase.

• Security checks integrated in the development workflow (linting, secret scanning, pre-commit)
• Developer security tooling

• No security gates in development
• Secrets not detected pre-commit

Perform security testing during development: SAST, DAST, dependency/SCA scanning and unit/integration security tests before artifacts are built.

• SAST/DAST results
• Software composition analysis (SCA) reports
• Security test coverage

• No automated security testing
• Dependencies not scanned

Harden container images: minimal base images, removal of unnecessary packages, non-root users and reduced attack surface.

• Hardened/minimal base-image standard
• Non-root and least-package image policy

• Bloated images with unnecessary packages
• Containers running as root

Scan container images for known vulnerabilities and misconfigurations before distribution, with policy on acceptable findings.

• Image vulnerability scan reports
• Policy gating on scan results

• Images distributed without scanning
• No remediation policy on findings

Harden deployment manifests: drop capabilities, set security contexts, resource limits and least-privilege specifications.

• Hardened manifest baselines (security contexts, dropped capabilities, resource limits)

• Manifests grant excessive privileges/capabilities

Scan deployment manifests (Kubernetes YAML, Helm charts, IaC) for insecure settings before deployment.

• Manifest/IaC security scan results
• Policy on insecure manifest settings

• Manifests not scanned
• Insecure defaults deployed

Secure the build pipeline (CI): isolated/ephemeral build environments, controlled build inputs, provenance generation and protection of pipeline credentials, supporting software supply chain integrity.

• Hardened CI build pipeline configuration
• Build provenance/attestation generation
• Pipeline credential protection

• Shared/persistent build agents
• No build provenance

Enforce runtime access controls: workload and human identity, authentication, authorization (RBAC), service-to-service auth (mTLS/service mesh) and least privilege.

• Workload + human identity and RBAC configuration
• Service-to-service authentication (mTLS/service mesh)

• Static/shared workload credentials
• No service-to-service auth

Protect runtime availability: resource limits/quotas, denial-of-service protection, autoscaling and resilience of cloud-native workloads.

• Resource limits/quotas + autoscaling configuration
• DoS protection at ingress

• No resource limits enabling resource exhaustion
• No DoS protection

Secure runtime compute: host/node hardening, orchestrator security, container runtime isolation (sandboxing, seccomp/AppArmor) and microservice protection.

• Node/host hardening baselines
• Container runtime isolation (seccomp/AppArmor/sandbox) config
• Orchestrator runtime security settings

• Unhardened nodes
• No runtime isolation profiles

Secure runtime storage: encryption of data at rest, secrets management, volume access control and persistent-data protection.

• Encryption at rest for volumes/data
• Secrets management solution (not plaintext)
• Storage access controls

• Unencrypted persistent volumes
• Secrets stored in plaintext/env

Apply cloud-native security principles: defense in depth, least privilege, zero trust, immutability, and secure-by-default across the 4C layers and lifecycle.

• Documented security principles adopted (least privilege, zero trust, immutability)
• Evidence principles are applied across layers

• Principles stated but not enforced

Maintain a cloud-native security stack mapped to lifecycle phases (scanning, policy-as-code, runtime detection, secrets, observability) and keep tooling current.

• Inventory of the security stack mapped to lifecycle phases
• Tooling maintenance/currency evidence

• Gaps in security tooling coverage

Conduct cloud-native threat modeling: enumerate assets, trust boundaries and threats (including the v2 ransomware use case) to drive control selection.

• Threat models for cloud-native systems covering trust boundaries
• Threat-driven control selection

• No threat modeling
• Trust boundaries undocumented