Custom seccomp profiles are useful only when they reach the node that starts a container. That sounds simple until a cluster has many node images, multiple runtime versions, and workloads that need different syscall policies. A file copied to one node is not a fleet-wide security control; it is a synchronization problem.
Kubernetes 1.38 targets an alpha solution to that distribution problem: an OCI seccomp profile can be stored in an OCI-compatible registry and referenced by an immutable digest from a Pod. The feature is tracked in KEP-6061. It is promising, but it is not a general “turn this on everywhere” switch. The API is alpha, runtime support is uneven, and a registry becomes part of the container-start path.
Why node-local profiles are awkward
Kubernetes already supports three important seccomp choices:
RuntimeDefaultuses the container runtime’s default policy.Localhostuses a JSON profile already present under the kubelet’s seccomp directory on the node.Unconfinedapplies no seccomp restrictions.
RuntimeDefault is a good baseline, but it is runtime-defined and may differ between container runtimes or runtime versions. Localhost allows a workload-specific policy, but every eligible node must have the right file before the Pod starts. Teams commonly solve that with baked node images, a DaemonSet, or an operator. Those approaches can work, but they couple profile rollout to node lifecycle or add another controller and set of resources.
The native OCI feature moves the distribution artifact into the same general ecosystem used for container content. The profile can be versioned and addressed by its content digest, while the workload template records exactly which version it expects.
What the alpha API looks like
The KEP’s example uses an OCI profile with a digest-pinned reference:
apiVersion: apps/v1
kind: Deployment
metadata:
name: api
spec:
selector:
matchLabels:
app: api
template:
metadata:
labels:
app: api
spec:
containers:
- name: api
image: registry.example.com/apps/api@sha256:IMAGE_DIGEST
securityContext:
seccompProfile:
type: OCI
oci:
reference: registry.example.com/security/api-seccomp@sha256:PROFILE_DIGEST
Treat this as a template, not a copy-and-apply recipe. The feature gate, Kubernetes version, API validation, registry credentials, and container runtime must all support the alpha implementation. Replace both placeholder digests with values produced by your own publishing process. This article did not publish an artifact or run the manifest.
The digest matters. KEP-6061 deliberately excludes mutable tag references. A tag can move, while a digest identifies content by hash. Updating a policy therefore means publishing a new artifact, changing the workload template to the new digest, and recreating containers. That is more explicit than silently resolving a tag during a later restart.
The pull path: kubelet, CRI, and registry
The design separates orchestration from profile parsing:
- The Pod declares the OCI reference and, where needed, image-pull credentials.
- The kubelet checks whether the node and runtime report support for OCI security profiles.
- The kubelet asks the CRI runtime to pull or locate the profile.
- The runtime validates and stores the profile, then applies it as the container is created.
- The Linux kernel enforces the resulting seccomp policy for that container.
The kubelet passes the reference and credentials through CRI operations; it does not need to understand the profile’s syscall rules. This lets a runtime own artifact storage, validation, caching, and application. The OCI specification is useful here because its descriptors and content-addressable references provide a common way to identify content beyond ordinary runnable images.
This is also why runtime capability checks are important. A Pod that schedules onto a node whose CRI does not implement the feature cannot be treated as if its profile were applied. KEP-6061 describes node-declared and CRI-reported support so the kubelet can reject or fail unsupported use rather than silently weakening the workload.
Baselines prevent an OCI profile from widening access
The most useful design detail is that an OCI profile is not intended to override the administrator’s baseline. The KEP supports layering an OCI profile over a RuntimeDefault or Localhost base. The runtime intersects the restrictions, producing an effective policy at least as restrictive as each input.
In practical terms, a platform team can establish a baseline and let application teams add narrower policies:
securityContext:
seccompProfile:
type: OCI
oci:
reference: registry.example.com/security/worker@sha256:PROFILE_DIGEST
baseProfile:
type: Localhost
localhostProfile: worker-baseline.json
The exact fields and supported combinations are alpha API details, so verify them against the Kubernetes release and runtime you operate. The security property is the important part: an application-owned OCI artifact should not be able to grant a syscall that the node’s baseline denies.
This layered model also makes baseline changes less disruptive. If the runtime applies the current baseline when a container is created, a tighter administrator policy can constrain the effective result without requiring every application profile to be rewritten. It does not remove the need for compatibility testing: a stricter policy can still break an application that legitimately needs a syscall.
A cautious rollout sequence
1. Establish the support matrix
Inventory Kubernetes versions, kubelet feature-gate settings, CRI runtimes, and node pools. The Kubernetes tracking issue identifies the feature as a v1.38 alpha target. Its implementation list shows CRI-O work merged, while containerd work was still a draft when this research was performed. Do not infer support from the Kubernetes API alone.
Start with one disposable node pool and one non-critical workload. Verify the runtime’s reported capability and inspect Pod events when a profile is unavailable. A failed pull or unsupported profile should be visible as a startup failure, not accepted as an unconfined fallback.
2. Publish a small, validated artifact
A seccomp profile is a policy, not a generic JSON blob. Validate it against the runtime-spec format and the runtime’s supported actions. Begin with a narrow workload profile and an explicit default action. Keep the source policy in the same review process as the workload code.
If your runtime supports signature policy for security-profile artifacts, require it. CRI-O’s merged KEP-6061 implementation validates artifact structure and size and applies its configured signature policy. A digest proves which bytes were selected; it does not prove that the bytes came from an authorized publisher.
3. Use a digest in the Pod template
Never put a mutable tag in the alpha field. Record the artifact digest in version control, review changes like image updates, and make the profile reference part of the deployment’s release metadata. Keep registry credentials scoped to the required repository and use the normal Kubernetes secret or credential-provider mechanism rather than embedding credentials in manifests.
4. Test failure and replacement
Test at least these cases before a broad rollout:
- the registry is unreachable;
- the digest does not exist;
- the artifact fails validation or signature policy;
- the runtime lacks OCI profile support;
- the profile blocks a syscall the application needs;
- a Pod is recreated after the profile is replaced.
Seccomp is applied when a container is created. Changing a registry artifact does not mutate the policy of an already-running container, and changing the digest in a template does not update existing containers until the workload recreates them. Plan a controlled rollout and a rollback digest.
What this feature does not solve
The alpha feature is a distribution primitive, not a profile-generation system. It does not tell you which syscalls an application needs, and it does not replace admission policy. Use admission controls to constrain which namespaces or teams may reference which registries and profile classes.
It also does not replace the Security Profiles Operator in every environment. The operator has broader workflows, including profile recording and composition, and its OCI artifact support predates the native Kubernetes API. The native path may reduce components for teams that only need runtime distribution, while SPO may remain the better fit for teams already using its recording and policy lifecycle.
Finally, OCI storage is not automatically trustworthy. Protect the registry, restrict who can publish, scan and validate profile artifacts, consider signatures and transparency records, and monitor pull failures. A compromised publishing pipeline can produce a perfectly valid digest containing an unsafe policy.
Should you use it yet?
Use the feature for controlled evaluation if you operate Kubernetes 1.38 alpha infrastructure, can confirm runtime support, and want to decouple profile releases from node-image releases. Keep production-critical workloads on the stable RuntimeDefault, a well-managed Localhost workflow, or an established operator until your runtime and Kubernetes support matrix is clear.
The practical promise is straightforward: publish a versioned syscall policy once, reference its immutable digest, and let the runtime fetch it where the workload starts. The practical warning is equally important: alpha APIs, runtime differences, registry availability, and policy compatibility remain your responsibility.