Skip to content
Français
Account: not signed in, sync available My learning
Select theme
Français

VAP+MAP vs Kyverno vs Gatekeeper: 2026 comparison

By updated

Improve this page

Logo Kubernetes

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.

CriterionVAP + MAP (native)KyvernoGatekeeper
InstallationNative, nothing to deployExternal component, 4 controllers (5 Pods)External component, 2 deployments, one with 3 replicas (4 Pods)
ValidationGA since 1.30YesYes
MutationGA since 1.36 (MutatingAdmissionPolicy)YesYes
GenerationNoYesNo
Image signature verificationNoYes (Cosign)No
Audit / reportingBasic via Warn/AuditPolicyReportsBuilt in
Main languageCELYAML + CELRego
CNCF statusNative Kubernetes featureGraduated (March 16, 2026)Built on OPA (Graduated)
2026 positioningNative duo of declarative validation + mutationRich engine, CEL transitionOPA/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.

Output (kubectl apply of a ClusterPolicy, Kyverno 1.19.1)
Warning: kyverno.io/v1 ClusterPolicy is deprecated and will be removed in a
future release; migrate to ValidatingPolicy, MutatingPolicy, GeneratingPolicy
or ImageValidatingPolicy (policies.kyverno.io), see
https://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

Enforcement model

EngineModelComment
VAPPolicy + Binding + Params (3 resources)Clear separation: logic / scope / values
KyvernoClusterPolicy (1 resource) or new CEL typesHistorical all-in-one, transition to dedicated types
GatekeeperTemplate + 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.

FeatureVAP + MAPKyvernoGatekeeper
ValidationGAYesYes
MutationGA in 1.36 (MAP)YesYes
GenerationNoUniqueNo
Image verificationNoCosign/SigstoreNo
ParametersparamRef/paramKindVariablesVia Constraint
Gradual rolloutWarn/Audit via validationActionsAudit modedryrun/warn
matchConditionsCELYAML/CELRego

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.

EngineCharacteristicImpact
VAPIn-process execution in the API serverNo network call to a webhook
KyvernoExternal HTTP webhookNetwork cost + external component
GatekeeperExternal HTTP webhook + RegoNetwork 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.

AspectVAPKyvernoGatekeeper
Policy libraryWrite your ownPolicy LibraryGatekeeper Library
Test CLIkubectlkyverno CLIgator (recommended) / opa
ArgoCD/FluxKubernetes manifestsManifests (CRD)Manifests (CRD)
CommunitySIG AuthCNCF 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 ClusterPolicy model 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.

CombinationUse caseBenefit
VAP + KyvernoVAP for critical validation, Kyverno for mutation/generationPerformance + full features
VAP + Gatekeeper auditVAP enforces, Gatekeeper for continuous compliancePerformance + detailed audit
Kyverno aloneFull coverage without RegoConceptual 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: true or allowPrivilegeEscalation: false by 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/v1
kind: ClusterPolicy
metadata:
name: deny-privileged
spec:
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.

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.

QuestionAnswerRecommendationWhy
Kubernetes 1.30+?NoKyverno or GatekeeperVAP not available
Simple validation only?YesVAPNative, no network call, no dependency
Simple mutation (label, default) on K8s 1.36+?YesMAPNative, no webhook
Mutation with generation of other resources?YesKyvernoOnly one to offer generation
Image signatures?YesKyvernoNative Cosign integration
OPA/Rego already used?YesGatekeeperReuse existing skills
Very complex policies?YesGatekeeperRego allows cross-references
Minimalist architecture?YesVAP + MAPNo 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 domainSkill named by the curriculumPossible 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

  1. VAP + MAP (GA in 1.30 and 1.36): native duo of validation and mutation, with no webhook.

  2. Kyverno brings mutation, generation and image signatures, but the CEL migration must be anticipated (ClusterPolicy deprecated, creation blocked since 1.20).

  3. Gatekeeper brings OPA/Rego and built-in audit, with a stronger VAP integration in 3.22, reserved for templates written in CEL.

  4. A combination is possible: VAP + MAP for validation and simple mutation, Kyverno for generation and signatures, but every added engine has an operating cost.

  5. 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

6 questions
5 min
80% to pass

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