AgentRules.org
RulesStacksClientsAuditorPrunerSelf-HealRFCsBenchmarkCLICI/CDAuthorsSubmit
This specification is maintained by the AgentRules Working Group. Have enhancements or want to claim maintainership?Submit Specification →
devopscritical PriorityID: k8s-v132-cel-admission-policy-enforcement

In-Tree CEL ValidatingAdmissionPolicy Enforcement for Kubernetes v1.32

Enforces Kubernetes v1.32 in-tree ValidatingAdmissionPolicy and ValidatingAdmissionPolicyBinding APIs over legacy out-of-tree validating webhooks. In-tree Common Expression Language (CEL) admission rules compile directly within the kube-apiserver binary, eliminating network latency, mutual TLS failure cascades, and bootstrap deadlocks. This standard guarantees deterministic, zero-dependency policy enforcement across all cluster-scoped and namespaced workloads.

Prohibited Anti-Pattern: Deploying Out-of-Tree Webhooks for Syntactic Invariants Causing API Server Outages

Export Ready-to-Drop Configuration

Select format below to copy code or download file directly.

---
description: In-Tree CEL ValidatingAdmissionPolicy Enforcement for Kubernetes v1.32 - Enforces Kubernetes v1.32 in-tree ValidatingAdmissionPolicy and ValidatingAdmissionPolicyBinding APIs over legacy out-of-tree validating webhooks. In-tree Common Expression Language (CEL) admission rules compile directly within the kube-apiserver binary, eliminating network latency, mutual TLS failure cascades, and bootstrap deadlocks. This standard guarantees deterministic, zero-dependency policy enforcement across all cluster-scoped and namespaced workloads.
globs: **/*.yaml, **/*.yml, charts/**/*.yaml, k8s/**/*.yaml, manifests/**/*.yaml
alwaysApply: true
verified_by: "agentrules.org"
license: "CC-BY-4.0"
source: "https://agentrules.org/rules/k8s-v132-cel-admission-policy-enforcement"
---

# In-Tree CEL ValidatingAdmissionPolicy Enforcement for Kubernetes v1.32

> **Severity**: CRITICAL | **Category**: devops
> **Anti-Pattern Warning**: Deploying Out-of-Tree Webhooks for Syntactic Invariants Causing API Server Outages

## System Constraints
You are a Principal Infrastructure Architect enforcing Kubernetes v1.32 In-Tree CEL Admission Policy Enforcement. Mandate the use of admissionregistration.k8s.io/v1 ValidatingAdmissionPolicy over ValidatingWebhookConfiguration for structural and state-invariant admission checks. Ensure all admission logic evaluates purely in-process via CEL, enforces strict failure policies, provides explicit failure messages via messageExpression, and optimizes matchConditions to prevent apiserver CPU saturation.

## Strict Guidelines
- Engineers MUST ALWAYS use `admissionregistration.k8s.io/v1` `ValidatingAdmissionPolicy` and `ValidatingAdmissionPolicyBinding` instead of `ValidatingWebhookConfiguration` for deterministic, non-external policy checks.
- Engineers MUST NOT introduce HTTP-based validating webhook servers (e.g., legacy Gatekeeper/Kyverno configurations) for rules that can be resolved via in-tree CEL expressions over `object`, `oldObject`, `request`, or `params`.
- ValidatingAdmissionPolicies MUST declare `failurePolicy: Fail` for enterprise compliance rules and explicitly define `matchConditions` to exclude unrelated namespaces (e.g., `kube-system`, `kube-node-lease`) prior to CEL evaluation.
- CEL expressions MUST utilize short-circuit boolean logic and list comprehensions (e.g., `containers.all(c, ...)` or `containers.exists(c, ...)`) to avoid apiserver evaluation budget exhaustion.
- ValidatingAdmissionPolicyBindings MUST strictly pair with policies using explicit `paramRef` namespaces or cluster-scoped parameters, preventing unbound or wildcard global bindings that hijack critical cluster recovery paths.

## Bad vs Good Implementations
### Replace Fragile Webhook with Native v1.32 ValidatingAdmissionPolicy

#### Bad Antipattern (AI Common Hallucination)
> **Why it fails**: Legacy validating webhooks require external HTTP round-trips to an in-cluster controller. If the webhook pods crash, become unschedulable during node drain, or suffer TLS cert expiry, all apiserver Pod creation fails (bootstrap deadlock).
```yaml
# Anti-Pattern: External webhook causing network hops, mTLS overhead, and cluster bootstrap deadlocks
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
  name: enforce-non-root-user
webhooks:
  - name: non-root.enterprise.internal
    rules:
      - apiGroups: [""]
        apiVersions: ["v1"]
        operations: ["CREATE", "UPDATE"]
        resources: ["pods"]
    clientConfig:
      service:
        name: webhook-service
        namespace: security-system
        path: /validate-non-root
        port: 443
      caBundle: LS0tLS1CRUdJTi...==
    admissionReviewVersions: ["v1"]
    sideEffects: None
    timeoutSeconds: 10
    failurePolicy: Fail
```

#### Production Standard (Correct)
> **Standard**: Evaluated strictly inside the kube-apiserver binary without HTTP calls. Provides deterministic sub-millisecond validation, zero external infrastructure dependencies, native namespace exclusion via matchConditions, and absolute resilience against cluster cold-start deadlocks.
```yaml
# Standard: In-Tree CEL ValidatingAdmissionPolicy natively compiled in kube-apiserver
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicy
metadata:
  name: enforce-non-root-user
spec:
  failurePolicy: Fail
  matchConstraints:
    resourceRules:
      - apiGroups: [""]
        apiVersions: ["v1"]
        operations: ["CREATE", "UPDATE"]
        resources: ["pods"]
  matchConditions:
    - name: exclude-kube-system
      expression: "request.namespace != 'kube-system'"
  validations:
    - expression: >-
        object.spec.containers.all(c,
          has(c.securityContext) &&
          has(c.securityContext.runAsNonRoot) &&
          c.securityContext.runAsNonRoot == true
        )
      message: "All pod containers must define securityContext.runAsNonRoot set to true."
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicyBinding
metadata:
  name: enforce-non-root-user-binding
spec:
  policyName: enforce-non-root-user
  validationActions: [Deny]
  matchResources:
    namespaceSelector:
      matchExpressions:
        - key: kubernetes.io/metadata.name
          operator: NotIn
          values: ["kube-system", "kube-public", "kube-node-lease"]
```
Recommended MCP Servers (mcp-serverlist.com)

Equip agent with system tools to verify code for this stack.

Kubernetes Cluster Inspector MCP
Inspects running cluster resources and verifies active ValidatingAdmissionPolicy CRDs directly against the target control plane.
Recommended Agent Skills (askills.dev)

Ready-to-use executable skill functions tailored to this stack.

Kubernetes CEL Policy CLI Validator
Dry-run and validate Common Expression Language (CEL) admission rules against mock API server workloads during CI/CD.
Architectural Specification & Invariant Rationale

Architectural Invariant Design: In-Tree CEL ValidatingAdmissionPolicy Enforcement for Kubernetes v1.32

In-Tree CEL ValidatingAdmissionPolicy Enforcement for Kubernetes v1.32 defines an industrial-grade behavioral standard for devops engineering. Enforces Kubernetes v1.32 in-tree ValidatingAdmissionPolicy and ValidatingAdmissionPolicyBinding APIs over legacy out-of-tree validating webhooks. In-tree Common Expression Language (CEL) admission rules compile directly within the kube-apiserver binary, eliminating network latency, mutual TLS failure cascades, and bootstrap deadlocks. This standard guarantees deterministic, zero-dependency policy enforcement across all cluster-scoped and namespaced workloads. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Deploying Out-of-Tree Webhooks for Syntactic Invariants Causing API Server Outages Without an explicit system instruction file, developers spend hours debugging silent failures.
Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure ModeAI Symptom (The Anti-Pattern)SeverityProduction Impact & Remedy
AI Hallucination & Deprecation DriftDeploying Out-of-Tree Webhooks for Syntactic Invariants Causing API Server OutagesCritical
Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production.
Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture InconsistencyAI assistants produce mixed paradigms across files, creating fragmented codebase conventions.Medium
Increases cognitive load during code reviews and leads to maintenance debt across engineering teams.
Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.
Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

1

Engineers MUST ALWAYS use `admissionregistration.k8s.io/v1` `ValidatingAdmissionPolicy` and `ValidatingAdmissionPolicyBinding` instead of `ValidatingWebhookConfiguration` for deterministic, non-external policy checks.

Engineers MUST ALWAYS use `admissionregistration.k8s.io/v1` `ValidatingAdmissionPolicy` and `ValidatingAdmissionPolicyBinding` instead of `ValidatingWebhookConfiguration` for deterministic, non-external policy checks.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
2

Engineers MUST NOT introduce HTTP-based validating webhook servers (e.g., legacy Gatekeeper/Kyverno configurations) for rules that can be resolved via in-tree CEL expressions over `object`, `oldObject`, `request`, or `params`.

Engineers MUST NOT introduce HTTP-based validating webhook servers (e.g., legacy Gatekeeper/Kyverno configurations) for rules that can be resolved via in-tree CEL expressions over `object`, `oldObject`, `request`, or `params`.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
3

ValidatingAdmissionPolicies MUST declare `failurePolicy

ValidatingAdmissionPolicies MUST declare `failurePolicy: Fail` for enterprise compliance rules and explicitly define `matchConditions` to exclude unrelated namespaces (e.g., `kube-system`, `kube-node-lease`) prior to CEL evaluation.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
4

CEL expressions MUST utilize short-circuit boolean logic and list comprehensions (e.g., `containers.all(c, ...)` or `containers.exists(c, ...)`) to avoid apiserver evaluation budget exhaustion.

CEL expressions MUST utilize short-circuit boolean logic and list comprehensions (e.g., `containers.all(c, ...)` or `containers.exists(c, ...)`) to avoid apiserver evaluation budget exhaustion.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
5

ValidatingAdmissionPolicyBindings MUST strictly pair with policies using explicit `paramRef` namespaces or cluster-scoped parameters, preventing unbound or wildcard global bindings that hijack critical cluster recovery paths.

ValidatingAdmissionPolicyBindings MUST strictly pair with policies using explicit `paramRef` namespaces or cluster-scoped parameters, preventing unbound or wildcard global bindings that hijack critical cluster recovery paths.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
Technical Questions & Answers

Frequently Asked Technical Questions

Common questions developers face when configuring AI coding assistants for this stack:

Q:Why is In-Tree CEL ValidatingAdmissionPolicy Enforcement for Kubernetes v1.32 critical for AI coding assistants?

Enforces Kubernetes v1.32 in-tree ValidatingAdmissionPolicy and ValidatingAdmissionPolicyBinding APIs over legacy out-of-tree validating webhooks. In-tree Common Expression Language (CEL) admission rules compile directly within the kube-apiserver binary, eliminating network latency, mutual TLS failure cascades, and bootstrap deadlocks. This standard guarantees deterministic, zero-dependency policy enforcement across all cluster-scoped and namespaced workloads. Without explicit behavioral boundaries, AI coding assistants (Cursor, Claude Code, Windsurf, Codex) rely on training data averages, which frequently produce deprecated, inefficient, or vulnerable code patterns.

Q:How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Deploying Out-of-Tree Webhooks for Syntactic Invariants Causing API Server Outages) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q:Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q:Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.

Open Specification · CC BY 4.0·Free for Personal, Team & Commercial In-Repo Use

Citation & Open Source Attribution Guidelines

This specification is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0). You are completely free to adapt and share this rule in your workspace. If citing, including in public AI benchmark datasets, or redistributing, attribution to AgentRules.org is required.

Related DEVOPS Rules

View all rules →
devops
86

Kubernetes Gateway API v1 HTTPRoute Canary and ReferenceGrant Invariants

Enforces strict conformance to Kubernetes Gateway API v1 specifications during migration from legacy Ingress controllers. Mandates explicit ReferenceGrant resources for cross-namespace routing, strict relative integer weighting for HTTPRoute canary releases, and explicit backendRef port declarations.

devops
118

ArgoCD ApplicationSet Matrix Generator Invariants & Cascade Deletion Guards

Enforces strict structural constraints on ArgoCD ApplicationSet Matrix generators combining cluster selectors and Git directories. Prevents catastrophic multi-cluster cascade pruning, accidental secret exposure through parameter interpolation, and runaway Application CR explosion via explicit sync policies, preservation finalizers, and parameter validation.

devops
40

Karpenter Resilient Topology, Interruption Queue, and Consolidation Budget Standard

Enforces deterministic disruption budgets, multi-instance-type diversification, and event-driven SQS interruption queue handling across Karpenter NodePools and EC2NodeClasses. Eliminates cascading eviction loops, instance starvation, and availability downtime during AWS Spot rebalances and underutilized node consolidation.

1 Rule in Stack

In-Tree