Three approaches let you set admission rules on Kubernetes: the native duo ValidatingAdmissionPolicy + MutatingAdmissionPolicy (VAP is GA since 1.30, MAP since 1.36), Kyverno and Gatekeeper. This comparison gives the state of each in November 2026, replayed on the same kind cluster running Kubernetes 1.37 with Kyverno 1.19.1 and Gatekeeper 3.23.1. It also explains the two transitions under way that change the choice.
What you will learn
This page helps you choose an admission policy engine for your cluster. By the end, you will know how to:
- compare VAP + MAP, Kyverno and Gatekeeper on language, enforcement model and ecosystem;
- spot the two transitions of 2026: Kyverno's migration to CEL and Gatekeeper's generation of VAPs;
- choose an engine from your own scenario, using the decision table;
- tell what migrates to VAP and MAP from what stays with Kyverno or Gatekeeper;
- know what the CKS asks for, and what it does not;
- make the cluster refuse without help what breaks a rule, with the module challenge, graded on the state of the cluster.
The 2026 landscape
This table summarizes the current characteristics of each solution. Look at the "Installation" and "Main language" rows first to understand the positioning: VAP+MAP are native and use CEL, Kyverno now writes its policies in CEL on a YAML structure, Gatekeeper relies on Rego (in French), the language of OPA. The "2026 positioning" row summarizes the changes under way.
| Criterion | VAP + MAP (native) | Kyverno | Gatekeeper |
|---|---|---|---|
| Installation | Native, nothing to deploy | External component, 4 controllers (5 Pods) | External component, 2 deployments, one with 3 replicas (4 Pods) |
| Validation | GA since 1.30 | Yes | Yes |
| Mutation | GA since 1.36 (MutatingAdmissionPolicy) | Yes | Yes |
| Generation | No | Yes | No |
| Image signature verification | No | Yes (Cosign) | No |
| Audit / reporting | Basic via Warn/Audit | PolicyReports | Built in |
| Main language | CEL | YAML + CEL | Rego |
| CNCF status | Native Kubernetes feature | Graduated (March 16, 2026) | Built on OPA (Graduated) |
| 2026 positioning | Native duo of declarative validation + mutation | Rich engine, CEL transition | OPA/Rego, VAP generation if the policy is in CEL |
The Pod counts come from a single cluster. They say nothing about performance under load, but they say something about the footprint: Kyverno deploys four separate controllers, admission, background, cleanup and reports, whereas Gatekeeper deploys two but runs its controller with three replicas by default. Neither is a minor add-on.
Three clarifications before reading this table, because they prevent three confusions.
MutatingAdmissionPolicy is GA since Kubernetes 1.36 and enabled by
default, its MutatingAdmissionPolicyBinding included. On the cluster of this
course, kubectl api-resources --api-group=admissionregistration.k8s.io lists
them in v1, cluster-scoped.
Gatekeeper is not a CNCF Graduated project: OPA, the project it is built on, is. Kyverno reached that level on March 16, 2026.
Finally, Kyverno has been moving since 1.17 toward CEL-based policy types.
ClusterPolicy is deprecated, the API reminds you on every apply in
1.19.1, and 1.20, published on November 12, 2026, blocks the creation of new
ClusterPolicy resources.
Transitions under way (do not ignore them)
A comparison of rule engines ages quickly, and 2026 is a turning point for two of the three. Reading them as frozen products would lead you to invest in a model that is being deprecated, or to set against each other two solutions that are precisely learning to coexist.
Kyverno 1.17: CEL migration
Kyverno 1.17 made the CEL-based policy types stable in
policies.kyverno.io/v1: ValidatingPolicy, MutatingPolicy,
GeneratingPolicy, ImageValidatingPolicy and DeletingPolicy, with an
official migration guide from the historical ClusterPolicy. Version 1.19, the
one of this comparison, shows a deprecation warning on every apply of a
ClusterPolicy, and 1.20, published on November 12, 2026, removes the old
engine and blocks their creation. If you invest in Kyverno today, anticipate
this switch: writing new policies on the old model means creating debt on day
one.
Warning: kyverno.io/v1 ClusterPolicy is deprecated and will be removed in afuture release; migrate to ValidatingPolicy, MutatingPolicy, GeneratingPolicyor ImageValidatingPolicy (policies.kyverno.io), seehttps://kyverno.io/docs/guides/migration-to-cel/Gatekeeper: VAP generation has a condition
One condition decides everything: Gatekeeper only generates a VAP from a
ConstraintTemplate written in CEL, that is, one that declares a code block
with engine: K8sNativeValidation. Checked on version 3.23.1, a Rego
template produces no VAP, and enforcement then goes entirely through the
webhook.
Since public policy libraries are written in Rego, the native path only opens at the price of a rewrite. This is what separates an announced convergence from an actual one.
When the condition is met, generation happens in two measurable steps: the
VAP first, its binding next, after a delay set by
--default-wait-for-vapb-generation. During this interval the VAP exists
without a binding, so it enforces nothing, and it is still the webhook that
rejects.
Gatekeeper 3.22: VAP integration
Since Gatekeeper 3.22, the --sync-vap-enforcement-scope flag defaults to
true: the VAPs that Gatekeeper generates take over the webhook's scope,
namespace exclusions and match criteria included, instead of applying more
widely than it does. Generation itself, --default-create-vap-for-templates,
has been enabled by default since 3.20 and remains subject to the CEL condition
above. The flag is also deprecated in 3.23 and disappears in 3.24, its behavior
becoming the norm. The consequence changes how the choice is framed. "VAP or
Gatekeeper" is no longer a clear-cut alternative: Gatekeeper can coexist
with the native mechanism, building on it instead of duplicating it.
Detailed comparison
The previous table gives the characteristics; this section shows what each solution gives you to write. This is what your teams handle every day: the same rule, forbid privileged containers, expressed in the three languages.
Policy language
The three tabs below express exactly the same rule, and all three were replayed. Compare them on readability for someone who did not write the policy, not on conciseness: a security rule is read far more often than it is written.
spec: validations: - expression: | !object.spec.containers.exists(c, has(c.securityContext) && has(c.securityContext.privileged) && c.securityContext.privileged ) message: "Conteneurs privilégiés interdits"Pros:
- Expressive and typed
- Same CEL language as CRD validation
- In-process execution (no webhook)
Cons:
- Syntax less intuitive than YAML
- Needs
has()to avoid errors on absent fields
apiVersion: policies.kyverno.io/v1kind: ValidatingPolicymetadata: name: deny-privilegedspec: validationActions: [Deny] matchConstraints: resourceRules: - apiGroups: [""] apiVersions: ["v1"] operations: ["CREATE", "UPDATE"] resources: ["pods"] validations: - expression: >- !object.spec.containers.exists(c, has(c.securityContext) && has(c.securityContext.privileged) && c.securityContext.privileged ) message: "Conteneurs privilégiés interdits"Replayed on Kyverno 1.19.1: READY true within a few seconds, then the request
is rejected with admission webhook "vpol.validate.kyverno.svc-fail" denied the request: Policy deny-privileged failed: Conteneurs privilégiés interdits.
Pros:
- Same CEL and same fields as VAP (
matchConstraints,validations), so the policy is portable - PolicyReports, test CLI, generation and image verification in the same tool
Cons:
- Historical YAML DSL (
ClusterPolicy,=()patterns) is deprecated, still worth knowing how to read - Operational complexity (webhook, HA)
violation[{"msg": msg}] { container := input.review.object.spec.containers[_] container.securityContext.privileged == true msg := sprintf("Conteneur '%v' privileged", [container.name])}Pros:
- General-purpose, very expressive language
- Reusable outside Kubernetes (Terraform, APIs)
- Cross-references, complex computations
Cons:
- Significant learning curve
- Harder debugging
Enforcement model
| Engine | Model | Comment |
|---|---|---|
| VAP | Policy + Binding + Params (3 resources) | Clear separation: logic / scope / values |
| Kyverno | ClusterPolicy (1 resource) or new CEL types | Historical all-in-one, transition to dedicated types |
| Gatekeeper | Template + Constraint (2 resources) | Reusable Rego template, the Constraint instantiates it |
The VAP and Gatekeeper models make it easier to separate responsibilities: the platform team creates the templates/policies, the application teams instantiate them.
Features
Each engine covers a different scope. Validation is available everywhere, but the differences show up on mutation (modifying objects before they are created), generation (automatically creating other resources), and image verification (Cosign/Sigstore). Among these three engines, Kyverno is the only one to offer generation and image signature verification.
| Feature | VAP + MAP | Kyverno | Gatekeeper |
|---|---|---|---|
| Validation | GA | Yes | Yes |
| Mutation | GA in 1.36 (MAP) | Yes | Yes |
| Generation | No | Unique | No |
| Image verification | No | Cosign/Sigstore | No |
| Parameters | paramRef/paramKind | Variables | Via Constraint |
| Gradual rollout | Warn/Audit via validationActions | Audit mode | dryrun/warn |
| matchConditions | CEL | YAML/CEL | Rego |
A misconception to dispel: VAP does have a gradual rollout mechanism. The
binding's validationActions field accepts Warn, which alerts without
blocking, and Audit, which records in the API server's audit log. You can
therefore observe the effect of a policy on real traffic before switching it to
rejection, exactly as with an external engine.
Performance
This is a qualitative approach: no latency measurement was made for this comparison.
| Engine | Characteristic | Impact |
|---|---|---|
| VAP | In-process execution in the API server | No network call to a webhook |
| Kyverno | External HTTP webhook | Network cost + external component |
| Gatekeeper | External HTTP webhook + Rego | Network cost + Rego evaluation |
VAP avoids the network call of a webhook for pure validation. This is an architectural advantage, whose size was not measured here.
Ecosystem
Beyond technical features, the ecosystem also matters. A ready-to-use policy library saves you from writing everything yourself. A dedicated CLI lets you test before deployment. All three engines are declared through manifests, so ArgoCD or Flux deploy them like everything else.
| Aspect | VAP | Kyverno | Gatekeeper |
|---|---|---|---|
| Policy library | Write your own | Policy Library | Gatekeeper Library |
| Test CLI | kubectl | kyverno CLI | gator (recommended) / opa |
| ArgoCD/Flux | Kubernetes manifests | Manifests (CRD) | Manifests (CRD) |
| Community | SIG Auth | CNCF Graduated (March 16, 2026) | Built on OPA (CNCF Graduated) |
Decision scenarios
None of the three solutions is better in the absolute, and the comparison table does not settle everything by itself. The three scenarios below start from the context rather than from the features: the context decides.
Choose VAP + MAP if...
- Kubernetes 1.36+ (native mutation and validation) or 1.30+ (validation only)
- Performance is critical (high-frequency validations)
- Minimalist architecture with no external component
- The team is comfortable with CEL
- Simple mutations (default label,
runAsNonRoot: true, default values)
Limits to know:
- No generation of other resources (auto-created NetworkPolicy, Secret, ConfigMap)
- No image signature verification (Cosign)
- No ready-made library
- No rich reporting like PolicyReports
Link with the CKS: the curriculum names no policy engine. The VAP + MAP duo has the advantage of installing nothing: it is available on any cluster running 1.30 or later for VAP, 1.36 or later for MAP.
Choose Kyverno if...
- Significant mutation needs (sidecar injection, defaults)
- Automatic generation of resources (NetworkPolicies, Secrets)
- Image verification (Cosign/Sigstore)
- The team is comfortable with YAML, ready to write its rules in CEL
Watch out in 2026:
- The historical
ClusterPolicymodel is deprecated in favor of CEL types, and 1.20 blocks its creation - Investing heavily in the old model creates immediate technical debt
- Operational complexity (webhook, HA, debugging)
Choose Gatekeeper if...
Gatekeeper keeps its own ground, and it holds on to its ecosystem more than to its features:
- OPA already used elsewhere (Terraform, CI, APIs)
- A team that masters Rego
- Complex policies with cross-references
- Need for built-in audit of existing resources
2026 evolution:
- Gatekeeper integrates better with VAP: it generates VAPs, provided the template is written in CEL
- Higher cognitive and operational cost than a native VAP
- Remains the OPA/Rego choice for teams invested in that ecosystem
Possible combinations
Nothing prevents you from combining several engines to benefit from their respective strengths. One approach is to use VAP for critical validations (performance) and Kyverno or Gatekeeper for advanced features (mutation, generation, audit). This table presents possible combinations, but beware of the risks described right after.
| Combination | Use case | Benefit |
|---|---|---|
| VAP + Kyverno | VAP for critical validation, Kyverno for mutation/generation | Performance + full features |
| VAP + Gatekeeper audit | VAP enforces, Gatekeeper for continuous compliance | Performance + detailed audit |
| Kyverno alone | Full coverage without Rego | Conceptual simplicity (CEL migration under way) |
Every engine you add multiplies the rejection points at admission, and the bill is paid in operations. Diagnosis gets harder, since you must first determine who rejected the request. Rules get duplicated from one engine to another without anyone noticing. Ordering effects appear between webhooks and native mechanisms. And the team's cognitive load grows accordingly. So only add an engine if it brings a truly missing capability, not for comfort.
Migrating to VAP + MAP
With VAP GA since 1.30 and MAP GA since 1.36, migrating validations and simple mutations from Kyverno/Gatekeeper to the native duo becomes relevant.
What migrates well
A migration to VAP succeeds on rules that can be phrased as a condition on the submitted object, with no need for anything else:
- Forbid privileged containers (VAP)
- Restrict allowed registries (VAP)
- Require certain labels (VAP)
- Block hostPath, hostNetwork (VAP)
- Limit replicas (VAP)
- Inject a default label (MAP
ApplyConfiguration) - Enforce
runAsNonRoot: trueorallowPrivilegeEscalation: falseby default (MAP) - Add standard annotations (MAP)
What does NOT migrate simply
The rules that resist all have one thing in common: they need something VAP does not provide, an external call, another object of the cluster, or the creation of a resource.
- Generation: neither VAP nor MAP generates other resources (Kyverno stays alone)
- Image verification: no native Cosign equivalent
- Complex policies: some Rego logic does not translate to CEL
- Cross-reference mutation (reading a ConfigMap, merging with a secret): limited in CEL
Conversion example
apiVersion: kyverno.io/v1kind: ClusterPolicymetadata: name: deny-privilegedspec: rules: - name: deny-privileged match: any: - resources: kinds: - Pod validate: failureAction: Enforce message: "Conteneurs privilégiés interdits" pattern: spec: containers: - =(securityContext): =(privileged): "false"Replayed on Kyverno 1.19.1, it rejects the Pod with the exact path of the field:
rule deny-privileged failed at path /spec/containers/0/securityContext/privileged/.
On 1.20, this policy can no longer be created: use the ValidatingPolicy seen above.
spec: validations: - expression: | !object.spec.containers.exists(c, has(c.securityContext) && has(c.securityContext.privileged) && c.securityContext.privileged ) message: "Conteneurs privilégiés interdits"Main difference: the DSL compares the resource to a pattern, and the =(securityContext) anchor makes the check conditional on an absent field; in CEL, has() plays that role, otherwise a Pod without a securityContext is rejected on an evaluation error. A Kyverno ValidatingPolicy already written in CEL, for its part, transposes almost as is.
Decision table
Go through the questions from top to bottom. As soon as an answer matches your situation, the associated recommendation is probably the right choice. If several rows match, favor the one that answers the most critical need for your context.
| Question | Answer | Recommendation | Why |
|---|---|---|---|
| Kubernetes 1.30+? | No | Kyverno or Gatekeeper | VAP not available |
| Simple validation only? | Yes | VAP | Native, no network call, no dependency |
| Simple mutation (label, default) on K8s 1.36+? | Yes | MAP | Native, no webhook |
| Mutation with generation of other resources? | Yes | Kyverno | Only one to offer generation |
| Image signatures? | Yes | Kyverno | Native Cosign integration |
| OPA/Rego already used? | Yes | Gatekeeper | Reuse existing skills |
| Very complex policies? | Yes | Gatekeeper | Rego allows cross-references |
| Minimalist architecture? | Yes | VAP + MAP | No external component |
What the CKS really expects
The CKS certification is about the ability to secure a cluster. Its official curriculum describes skills and names no policy engine: not Kyverno, not Gatekeeper, not OPA, not ValidatingAdmissionPolicy. The table below shows how these engines can meet two of those skills.
| CKS domain | Skill named by the curriculum | Possible tool |
|---|---|---|
| Minimize Microservice Vulnerabilities | "Use appropriate pod security standards" | PSA, VAP, Kyverno, Gatekeeper |
| Supply Chain Security | "Secure your supply chain (permitted registries, sign and validate artifacts, etc.)" | VAP or Gatekeeper for registries, Kyverno (Cosign) for signatures |
Hands-on practice
Choosing an admission engine proves nothing until the cluster has refused a real Pod. The challenge below has you demonstrate it without help, with the native Kubernetes mechanisms.
Challenge: have the cluster refuse what breaks a rule
The challenge is the unaided proof of the module "Admission policies", and it is graded on the state of the cluster you leave behind, not on the commands you typed. The kubeadm cluster admits everything. You make it refuse, at creation, what breaks a rule: the restricted standard on one namespace, a privileged Pod that you rebuild without any of its flaws on another, and a native admission policy that refuses images designated by a tag on a third, without touching the rest. No procedure is given to you.
The validation reads ten states, with no solution or value to copy. It reads the admitted Pods, enters the new Pod to count what it sees, and submits real Pods: in the first namespace without creating anything, in the other two by creating them and then removing them at once.
Passing requires 70 points out of 100, and there is no hint. Two states are blocking and must pass whatever the total: admission refuses a Pod that violates the standard and accepts a compliant Pod; in production, an image designated by a tag is refused while an image pinned by digest passes, without the other namespaces being affected.
dsoxlab check lists the states that are not satisfied, without saying how to fix them: the lesson to go back to is the one that teaches that state. The challenge builds on this lesson, on Pod Security Standards, on ValidatingAdmissionPolicy (in French) and on the admission controllers (in French).
Key points
-
VAP + MAP (GA in 1.30 and 1.36): native duo of validation and mutation, with no webhook.
-
Kyverno brings mutation, generation and image signatures, but the CEL migration must be anticipated (
ClusterPolicydeprecated, creation blocked since 1.20). -
Gatekeeper brings OPA/Rego and built-in audit, with a stronger VAP integration in 3.22, reserved for templates written in CEL.
-
A combination is possible: VAP + MAP for validation and simple mutation, Kyverno for generation and signatures, but every added engine has an operating cost.
-
The CKS describes security skills and names neither VAP, nor Kyverno, nor Gatekeeper.
Knowledge check
Six questions on what really decides between these three engines, and on the two transitions of 2026 that change the picture.
Knowledge check
Check what you have learned with this interactive quiz
How it works
- The timer starts when you click Start
- Multiple choice, true/false and short answer questions
- You can move between questions
- Detailed results are shown at the end
Starts the quiz and the timer
Review
(0/0)Score by domain
A domain groups several guides and gets several questions, so its score is more reliable than a per-topic score, which often rests on a single question.
Summary
Strengths
No topic passed at 80% on at least two questions yet.
Weak areas
No topic below the pass mark.
Recommended next
Hints before you try again?
Continue the course: Pod-to-pod mTLS: encrypting traffic between services
A new full quiz with random questions
Work again only on the questions you missed