kubernetes

Kubernetes SecurityContext Explained

Kubernetes SecurityContext Explained

By Shubhankar Tripathi • • 5 min read

Kubernetes SecurityContext Explained

bitcodematrix.com | Kubernetes Series

1. Introduction

Authentication and RBAC decide who may talk to the Kubernetes API. They say nothing about what a container can do once it is running. By default, a container may run as the root user, hold a generous set of Linux capabilities, write anywhere in its file system, gain new privileges through setuid programs, and call almost any system call. If an attacker finds a vulnerability in your application, all of those defaults become the attacker's tools.

The securityContext is the part of the Pod specification that tightens these defaults. It lets you control which user and group the processes run as, which privileges and capabilities they hold, whether the root file system is writable, which system calls are allowed, and how volumes are owned. This article explains every important field, how Pod-level and container-level settings interact, how to build a hardened Pod, how the Pod Security Standards enforce good settings across a namespace, and how to verify and troubleshoot the result. It complements the earlier articles in this series on RBAC, ServiceAccounts, Secrets and ephemeral storage.

2. Why SecurityContext Matters

A container is not a virtual machine. It is an ordinary Linux process that the kernel isolates with namespaces (what it can see), control groups (how much it can use) and a set of restrictions on what it may do. All containers on a node share the same kernel, so the quality of that isolation determines how far an attacker can get after compromising one application.

The security context works on the restrictions part of that isolation. A useful way to think about it is as reducing the blast radius:

  • If the process runs as a non-root user, a compromise has fewer rights inside the container and over mounted volumes.

  • If all capabilities are dropped, the process cannot perform privileged operations such as changing file ownership arbitrarily or crafting raw network packets.

  • If the root file system is read-only, an attacker cannot drop tools or modify binaries in the image.

  • If privilege escalation is blocked, setuid binaries cannot raise the process's rights.

  • If a seccomp profile is applied, dangerous system calls that are used in kernel exploits are unavailable.

None of this replaces patching and secure coding. It is defence in depth: it raises the cost of an attack and limits what a successful one achieves.

Note that "root" inside a container is still UID 0 as far as the kernel is concerned, unless user namespaces are used. Container isolation makes root in a container less powerful than root on the host, but several well-known container escapes start from containers that run as root or hold powerful capabilities. That is why running as non-root is the single most valuable setting.

3. Where SecurityContext Is Defined

There are two places, and they have different fields:

  • spec.securityContext (the Pod-level context) applies to all containers in the Pod, including init containers, and to the Pod's volumes.

  • spec.containers[].securityContext (the container-level context) applies to one container, and overrides the Pod-level value for any field that exists in both.

Field

Pod level

Container level

Purpose

runAsUser, runAsGroup

Yes

Yes

The numeric user and group of the process

runAsNonRoot

Yes

Yes

Refuse to start if the user would be root

seccompProfile

Yes

Yes

Filter system calls

seLinuxOptions

Yes

Yes

SELinux labels

appArmorProfile

Yes

Yes

AppArmor confinement

fsGroup, fsGroupChangePolicy

Yes

No

Group ownership of volumes

supplementalGroups

Yes

No

Additional group IDs for the process

sysctls

Yes

No

Kernel parameters for the Pod

privileged

No

Yes

Run with extended privileges

allowPrivilegeEscalation

No

Yes

Allow gaining more privileges than the parent

capabilities

No

Yes

Add or drop Linux capabilities

readOnlyRootFilesystem

No

Yes

Mount the root file system read-only

 

A common mistake is to place a container-only field, such as capabilities, at the Pod level. The API server rejects unknown fields in strict validation, or silently ignores them in some tools, so the intended protection is missing. When in doubt, check the table above or run kubectl explain pod.spec.securityContext and kubectl explain pod.spec.containers.securityContext.

4. Users, Groups and Volume Ownership

4.1 runAsUser, runAsGroup and runAsNonRoot

spec:

  securityContext:

    runAsUser: 10001

    runAsGroup: 10001

    runAsNonRoot: true

The runAsUser and runAsGroup fields override the user and group that the image defines, using numeric IDs. Choose IDs that are high (above 10000 is a common convention) so that they do not collide with real accounts on the node. The runAsNonRoot field does not choose a user; it is a check. The kubelet refuses to start the container if it would run as UID 0. This is a good safety net, because it catches an image that unexpectedly runs as root.

One subtlety causes frequent confusion. If runAsNonRoot is true and the image defines its user by name (for example USER appuser) rather than by number, the kubelet cannot verify that the user is not root, and the container fails with an error saying that the image has a non-numeric user. The fix is to set runAsUser explicitly to a number, or to build the image with a numeric USER instruction.

4.2 fsGroup and Volume Permissions

Volumes are often owned by root, and a non-root process then cannot write to them. The fsGroup field tells Kubernetes to make supported volumes writable for that group: the files get the group ID, the setgid bit is set on directories so that new files inherit the group, and the process receives the group as a supplementary group.

spec:

  securityContext:

    runAsUser: 10001

    fsGroup: 20000

    fsGroupChangePolicy: OnRootMismatch

  • By default, Kubernetes changes ownership recursively on every mount, which can be very slow on volumes with many files. Setting fsGroupChangePolicy to OnRootMismatch makes it change ownership only if the volume's root directory does not already match, which speeds up Pod start-up considerably.

  • Whether fsGroup applies depends on the volume type and the CSI driver, which declares its behaviour through fsGroupPolicy. Some volume types, such as certain network file systems and hostPath, may ignore it.

  • supplementalGroups adds extra group IDs to the process, which is useful for shared storage where access is controlled by group membership on the server.

The storage articles in this series show the typical symptoms when these settings are missing: permission denied when a database writes to its data directory after a restart.

4.3 Building Images for Non-Root

  • Create a user with a fixed numeric ID in the image, and set USER to that number.

  • Make sure the application files are readable, and the directories that it writes to are writable, by that user or group.

  • Avoid listening on ports below 1024, or add only the capability needed (see Section 6).

  • Prefer minimal base images, such as distroless or slim images, which contain fewer tools for an attacker to use. Many popular images also publish unprivileged variants that are designed for non-root operation.

5. Privileged Mode and Privilege Escalation

5.1 privileged

A container with privileged: true is almost not isolated from the host. It receives all capabilities, can access host devices and can often modify the host's kernel settings and mount file systems. It is intended only for specific infrastructure components, such as some CNI and CSI node plugins and low-level monitoring agents. For application workloads, there is virtually never a good reason to use it, and its presence in a manifest should trigger a security review.

5.2 allowPrivilegeEscalation

This field controls whether a process may gain more privileges than its parent, for example by executing a setuid-root binary. Internally it sets the Linux no_new_privs flag. The default is true, and it is forced to true when the container is privileged or holds the CAP_SYS_ADMIN capability. For nearly every application, set it to false:

containers:

- name: app

  securityContext:

    allowPrivilegeEscalation: false

Programs that depend on setuid helpers or on switching users with su or sudo inside the container will stop working, which is intended. Such images should be redesigned to start directly as the target user.

6. Linux Capabilities

Traditionally, UID 0 was all-powerful. Linux splits those powers into separate capabilities, such as binding to low ports or changing file ownership, so that a process can hold only what it needs. Container runtimes give containers a default set of capabilities, which is smaller than the full set but still includes powers that most applications never use.

Capability

What it allows and typical guidance

NET_BIND_SERVICE

Bind to ports below 1024. The only capability that the restricted Pod Security profile lets you add back

NET_RAW

Create raw sockets, as used by ping and packet crafting. Part of the common default set, and dangerous in the wrong hands, for example for network spoofing. Drop it

CHOWN, FOWNER, DAC_OVERRIDE

Change file ownership, and bypass file permission checks. Needed by some entrypoint scripts; avoid by preparing file ownership at build time

SETUID, SETGID

Change the process's user and group IDs, used by images that start as root and then drop privileges. Not needed when the container starts as the final user

SYS_PTRACE

Inspect and manipulate other processes. Debugging only

SYS_ADMIN

A very broad capability that enables mounting and many other operations. Treat it as nearly equivalent to privileged. Avoid

NET_ADMIN

Configure network interfaces, routing and firewalls. Needed by some network tools, and powerful. Avoid for applications

 

The recommended approach is to drop everything and add back only what is proven necessary:

containers:

- name: web

  securityContext:

    capabilities:

      drop: ["ALL"]

      add: ["NET_BIND_SERVICE"]

To find what an application really needs, drop all capabilities in a test environment and watch for "operation not permitted" errors. Often nothing needs to be added back. For the port issue, the simplest solution is to make the application listen on a port above 1024, such as 8080, and map it with the Service. Alternatively, Kubernetes allows the safe sysctl net.ipv4.ip_unprivileged_port_start to lower the threshold for the Pod, as described in Section 9.

7. A Read-Only Root File System

Setting readOnlyRootFilesystem: true mounts the container's file system read-only. Attackers cannot modify application binaries, plant scripts or change configuration there, and unexpected writes become visible failures instead of silent state. Applications that need to write somewhere get explicit, bounded, writable volumes:

containers:

- name: app

  image: example/app:1.0

  securityContext:

    readOnlyRootFilesystem: true

  volumeMounts:

  - name: tmp

    mountPath: /tmp

  - name: cache

    mountPath: /var/cache/app

volumes:

- name: tmp

  emptyDir:

    sizeLimit: 100Mi

- name: cache

  emptyDir:

    sizeLimit: 200Mi

Typical writable locations include /tmp, a cache directory, a run directory for PID files and sockets, and a log directory if the application does not log to standard output. Find them by running the application with a read-only root in a test environment, and fixing each "read-only file system" error with a targeted emptyDir. As the ephemeral storage article explains, these volumes count against the Pod's ephemeral storage, so give them size limits. This setting also makes disk usage predictable.

8. System Call and Mandatory Access Control Profiles

8.1 seccomp

Seccomp restricts which system calls a process may make. The kernel has several hundred, and a typical application uses a small fraction of them, while kernel exploits often rely on rarely used calls. The container runtime ships a default profile that blocks the most dangerous ones. You enable it per Pod or container:

spec:

  securityContext:

    seccompProfile:

      type: RuntimeDefault

Type

Meaning

RuntimeDefault

The container runtime's default profile. The recommended baseline for nearly all workloads

Localhost

A custom profile file on the node, referenced by localhostProfile. Needs distribution of the file to all nodes

Unconfined

No filtering. This is what many clusters used historically when nothing was set. Avoid

 

The kubelet can also be configured to apply RuntimeDefault to every Pod that does not set a profile, using a kubelet setting that became generally available in Kubernetes 1.27. Do not rely on node defaults alone, because explicit settings document intent and are enforced by the Pod Security Standards.

8.2 AppArmor

AppArmor is a Linux security module, available on distributions that ship it, which confines a program to a profile of allowed file, network and capability access. Current Kubernetes versions support it through the appArmorProfile field, with the same type values of RuntimeDefault, Localhost and Unconfined, replacing the older annotation-based method. The node must have AppArmor enabled, and the profile must be loaded for Localhost profiles.

securityContext:

  appArmorProfile:

    type: RuntimeDefault

8.3 SELinux

On nodes that use SELinux, such as those running Red Hat family distributions, containers run with an SELinux label, and volumes must carry a compatible label. The seLinuxOptions field lets you set the level, role, type and user. In most clusters you should leave the type to the runtime and use only the level where isolation between Pods is required. Setting these fields wrongly causes "permission denied" errors on volumes, which is a typical symptom on SELinux nodes. Check which of AppArmor or SELinux your nodes use before you plan a profile strategy.

9. sysctls

The sysctls field in the Pod security context sets kernel parameters inside the Pod's own namespaces. Kubernetes separates them into safe sysctls, which are namespaced and cannot affect other Pods or the node, and unsafe ones, which can. Safe sysctls are allowed by default, and unsafe ones must be explicitly enabled on each node by the cluster administrator and should be avoided in shared clusters.

spec:

  securityContext:

    sysctls:

    - name: net.ipv4.ip_unprivileged_port_start

      value: "80"

This example lets non-root processes bind to port 80 and above without any added capability, and is part of the set of safe sysctls. The exact list of safe sysctls grows over time, so check the Kubernetes documentation for your version. If a Pod asks for a sysctl that is not allowed, it fails to start with a message that the sysctl is forbidden.

10. User Namespaces

A relatively recent addition is support for user namespaces, enabled by setting hostUsers to false in the Pod specification. The container's UIDs are then mapped to a different, unprivileged range on the host, so that root inside the container is an ordinary unprivileged user outside. This substantially weakens many container escape techniques, and it also allows some workloads to use capabilities safely inside their own namespace. Support depends on the Kubernetes version, the container runtime, the kernel and the file system, so check the requirements before relying on it, and treat it as an extra layer rather than a replacement for running as non-root.

spec:

  hostUsers: false

11. Related Settings Outside the SecurityContext

Hardening a Pod is not only about the securityContext fields. Several other Pod settings affect how isolated it is and should be reviewed together:

Setting

Why it matters

hostNetwork, hostPID, hostIPC

Share the node's network, process or IPC namespaces with the Pod. They break isolation, so keep them false for applications

hostPort

Binds a port on the node and ties the Pod to nodes. Avoid

hostPath volumes

Expose node directories to the container, with potential access to credentials and the container runtime. Avoid for applications

automountServiceAccountToken

Set to false when the Pod does not call the Kubernetes API, so that no credential is mounted

shareProcessNamespace

Lets containers in a Pod see each other's processes. Enable only when needed, for example for debugging

resources (requests and limits)

Prevent one container from exhausting node resources, which is also a security and availability concern

NetworkPolicy

Limits which Pods and addresses a compromised container can reach

Image provenance

Use trusted, scanned and pinned images, because securityContext cannot make an untrusted image safe

 

12. Pod Security Standards and Admission

Individual developers will not always remember every setting, so Kubernetes provides a way to enforce minimum standards. The Pod Security Standards define three profiles, and the built-in Pod Security admission controller checks Pods against them according to labels on the namespace.

Profile

Intent

Main requirements

Privileged

No restrictions, for trusted system components

None

Baseline

Block known privilege escalations while staying easy to adopt

No privileged containers, no host namespaces, no hostPath volumes or host ports, a limited set of capabilities, and restricted use of other risky features

Restricted

Follow current hardening best practices

Everything in baseline, plus: run as non-root, allowPrivilegeEscalation set to false, capabilities dropped (only NET_BIND_SERVICE may be added), a seccomp profile of RuntimeDefault or Localhost, and a limited set of volume types

 

Each namespace can apply a profile in three modes: enforce rejects violating Pods, audit records violations in the audit log, and warn shows a warning to the user. You configure them with labels:

apiVersion: v1

kind: Namespace

metadata:

  name: shop

  labels:

    pod-security.kubernetes.io/enforce: restricted

    pod-security.kubernetes.io/enforce-version: latest

    pod-security.kubernetes.io/audit: restricted

    pod-security.kubernetes.io/warn: restricted

When a Pod violates the profile, the API server rejects it with a message that lists each violated rule, such as allowPrivilegeEscalation not being set to false, capabilities not being dropped, runAsNonRoot not being true, or the seccomp profile missing. That message is also your checklist for what to add to the manifest.

12.1 Rolling It Out Safely

  1. Start in a test namespace, and set warn and audit to restricted without enforcing. Deploy your normal workloads and read the warnings.

kubectl label --dry-run=server --overwrite namespace shop \

  pod-security.kubernetes.io/enforce=restricted

  1. Use the server-side dry run above to see which existing Pods in a namespace would violate a profile, before you enforce it.

  2. Fix the manifests, or the images, until the warnings disappear. Add the missing securityContext fields and writable volumes.

  3. Turn on enforce for the namespace. Existing Pods keep running, but new or recreated Pods must comply.

  4. Keep privileged system components in their own namespaces with the privileged profile, and restrict who can create Pods there.

Pod Security admission is deliberately simple. For finer rules, such as requiring specific user ID ranges, forbidding certain images, or setting defaults automatically, policy engines such as Kyverno and OPA Gatekeeper, or the built-in ValidatingAdmissionPolicy, can complement it.

13. A Hardened Pod, Step by Step

The Deployment below combines the settings from this article. It satisfies the restricted profile:

apiVersion: apps/v1

kind: Deployment

metadata:

  name: web

  namespace: shop

spec:

  replicas: 2

  selector:

    matchLabels:

      app: web

  template:

    metadata:

      labels:

        app: web

    spec:

      automountServiceAccountToken: false

      securityContext:

        runAsNonRoot: true

        runAsUser: 10001

        runAsGroup: 10001

        fsGroup: 10001

        fsGroupChangePolicy: OnRootMismatch

        seccompProfile:

          type: RuntimeDefault

      containers:

      - name: web

        image: example/web:1.0

        ports:

        - containerPort: 8080

        securityContext:

          allowPrivilegeEscalation: false

          readOnlyRootFilesystem: true

          capabilities:

            drop: ["ALL"]

        resources:

          requests:

            cpu: 100m

            memory: 128Mi

          limits:

            memory: 256Mi

        volumeMounts:

        - name: tmp

          mountPath: /tmp

      volumes:

      - name: tmp

        emptyDir:

          sizeLimit: 100Mi

Setting

What it achieves

automountServiceAccountToken: false

No API credential in the Pod

runAsNonRoot, runAsUser and runAsGroup

The process runs as an unprivileged numeric user, and the kubelet verifies it

fsGroup with OnRootMismatch

Mounted volumes are writable by the group, with fast start-up

seccompProfile RuntimeDefault

Dangerous system calls are blocked

allowPrivilegeEscalation: false

No gaining of privileges through setuid programs

readOnlyRootFilesystem: true

The image's files cannot be modified

capabilities drop ALL

No special kernel privileges

Port 8080

Non-root processes can bind without extra capabilities

Resource requests and limits

Bounded resource use

emptyDir at /tmp with a size limit

A small, bounded writable scratch area

 

The image name is a placeholder. Your application must be built to run in this mode: listening on a high port, with writable paths only under the mounted volumes.

14. Verifying the Settings in a Running Container

Never assume that a manifest produced the protection you intended. Check inside the container:

kubectl exec -n shop deploy/web -- id

kubectl exec -n shop deploy/web -- \

  sh -c 'grep -E "NoNewPrivs|Seccomp|CapEff" /proc/self/status'

kubectl exec -n shop deploy/web -- sh -c 'touch /testfile; echo $?'

kubectl exec -n shop deploy/web -- sh -c 'touch /tmp/testfile; echo $?'

Check

What a hardened container shows

id

The numeric user and group that you set, not uid=0

NoNewPrivs

1, meaning that privilege escalation is blocked

Seccomp

2, meaning that a seccomp filter is active. 0 means no filtering

CapEff

All zeros if every capability is dropped

Writing to the root file system

Fails with a read-only file system error

Writing to a mounted emptyDir

Succeeds

 

The commands assume that the image contains a shell and standard tools. Minimal and distroless images may not, in which case use an ephemeral debug container with kubectl debug to inspect the Pod. You can also review the effective settings in the Pod specification with kubectl get pod -o yaml, remembering that defaults from admission controllers show up there too.

15. Hands-On Walkthrough

  1. Create a namespace and a Pod with default settings.

kubectl create namespace sc-demo

kubectl run default-pod -n sc-demo --image=busybox:1.36 \

  --restart=Never --command -- sleep 3600

  1. Inspect it.

kubectl exec -n sc-demo default-pod -- id

kubectl exec -n sc-demo default-pod -- \

  sh -c 'grep -E "NoNewPrivs|Seccomp|CapEff" /proc/self/status; touch /testfile && echo writable'

You will typically see uid=0 (root), a non-zero set of effective capabilities, NoNewPrivs 0, and a writable root file system. The Seccomp value depends on whether the node applies a default profile.

  1. Create a hardened Pod.

apiVersion: v1

kind: Pod

metadata:

  name: hardened-pod

  namespace: sc-demo

spec:

  automountServiceAccountToken: false

  securityContext:

    runAsNonRoot: true

    runAsUser: 10001

    runAsGroup: 10001

    seccompProfile:

      type: RuntimeDefault

  containers:

  - name: app

    image: busybox:1.36

    command: ["sleep", "3600"]

    securityContext:

      allowPrivilegeEscalation: false

      readOnlyRootFilesystem: true

      capabilities:

        drop: ["ALL"]

    volumeMounts:

    - name: tmp

      mountPath: /tmp

  volumes:

  - name: tmp

    emptyDir: {}

  1. Inspect the hardened Pod, and compare.

kubectl exec -n sc-demo hardened-pod -- id

kubectl exec -n sc-demo hardened-pod -- \

  sh -c 'grep -E "NoNewPrivs|Seccomp|CapEff" /proc/self/status'

kubectl exec -n sc-demo hardened-pod -- sh -c 'touch /testfile'

kubectl exec -n sc-demo hardened-pod -- sh -c 'touch /tmp/testfile && echo ok'

The process now runs as user 10001, NoNewPrivs is 1, Seccomp is 2, the capability set is empty, writing to the root file system fails, and writing to /tmp works.

  1. Enforce the restricted profile on the namespace, and try the default Pod again.

kubectl label namespace sc-demo \

  pod-security.kubernetes.io/enforce=restricted --overwrite

kubectl run another-default -n sc-demo --image=busybox:1.36 \

  --restart=Never --command -- sleep 3600

The API server rejects the new Pod and lists the violations: allowPrivilegeEscalation not set to false, capabilities not dropped, runAsNonRoot not true and the seccomp profile missing. Existing Pods were not affected by the label.

  1. Clean up.

kubectl delete namespace sc-demo

16. Troubleshooting

Symptom

Likely cause and check

CreateContainerConfigError: image has non-numeric user, cannot verify user is non-root

runAsNonRoot is true and the image uses a named user. Set runAsUser to a numeric ID

Container fails with runAsNonRoot error for an image that runs as root

The image is designed for root. Use a non-root variant or rebuild it, or set a suitable runAsUser if the files permit

Permission denied writing to a mounted volume

Ownership mismatch. Set fsGroup, check the volume type and CSI fsGroupPolicy, and review the numeric user and group

Read-only file system errors

readOnlyRootFilesystem is on and the application writes outside volumes. Add targeted emptyDir mounts for those paths

Cannot bind to port 80 as non-root

Listen on a port above 1024, set the safe sysctl for the unprivileged port range, or add NET_BIND_SERVICE

Operation not permitted after dropping capabilities

The application or its entrypoint needs a specific capability, often CHOWN, SETUID or SETGID. Fix the image first, and add back only what is proven necessary

Pod rejected: violates PodSecurity "restricted"

The message lists each violated rule. Add the missing securityContext fields, or move the workload to an appropriate namespace

Syscall errors or a crash with seccomp enabled

The application needs a call that the profile blocks. Test with a custom Localhost profile, and avoid Unconfined as a shortcut

Pod fails to start with a forbidden sysctl error

The sysctl is not in the safe set, and the node does not allow unsafe sysctls. Choose a safe one or change the design

Permission denied on volumes on SELinux nodes

Label mismatch. Review seLinuxOptions and the volume's relabelling behaviour

Fields appear to have no effect

A container-only field was set at the Pod level, or a container-level value overrides the Pod-level one. Compare with the field table in Section 3

Pod start-up is very slow with large volumes

Recursive fsGroup ownership changes. Set fsGroupChangePolicy to OnRootMismatch

 

17. Best Practices

  • Run every application as a non-root numeric user, set runAsNonRoot as a safety check, and build images to support it.

  • Set allowPrivilegeEscalation to false and drop all capabilities by default, adding back only what has been proven necessary.

  • Use a read-only root file system with small, size-limited emptyDir volumes for the paths that need writing.

  • Always set a seccomp profile of RuntimeDefault, and use AppArmor or SELinux profiles where your nodes support them.

  • Never use privileged mode, host namespaces or hostPath for application workloads, and confine the few components that need them to dedicated namespaces.

  • Set fsGroup and fsGroupChangePolicy for workloads that use persistent volumes.

  • Enforce the restricted Pod Security profile on application namespaces, rolling it out with warn and audit modes first.

  • Use admission policies to enforce rules that Pod Security cannot, and to supply safe defaults.

  • Combine securityContext with RBAC, NetworkPolicies, token minimisation, resource limits and image scanning, because no single control is enough.

  • Verify the effective settings inside running containers, and include these checks in tests or CI.

  • Share a hardened Pod template or Helm chart defaults across teams, so that secure settings are the easy path.

18. Conclusion

The securityContext is where Kubernetes lets you decide how much power a container really has. Its defaults favour compatibility, which means that an unconfigured Pod often runs as root with many capabilities, a writable file system and few syscall restrictions. A handful of fields change that picture: a non-root user, no privilege escalation, no capabilities, a read-only root file system and a seccomp profile. Together they turn a compromised container from a serious foothold into a tightly boxed process.

Make these settings the standard, not the exception. Build images that run without root, enforce the restricted Pod Security profile, verify the results inside running containers and combine them with the other layers of Kubernetes security. Then every new workload starts from a hardened baseline, and the effort of securing the cluster grows far more slowly than the number of applications that run on it.