roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Write Kyverno policies that admit, patch or refuse Kubernetes resources, and explain what each rule checks. Covers the admission path, validate and mutate rules, signed images, reports and exceptions.
159 of 159 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 159 new. 0 cut, outside your plan.
Kyverno is asked about where a team already runs it: in the Kubernetes or cluster-security round of a platform, DevOps, SRE or DevSecOps loop, and sometimes as a live exercise in which you write a policy on the spot, one that requires resource limits or refuses images tagged `latest`. Interviewers usually read the policy back to you and ask what it actually lets through. The questions are about behaviour that surprises people in production. A rule matches only Pods, so why does it refuse a Deployment, and why does the same violation inside a CronJob slip past? Why does a pattern with an anchor on the wrong key admit every container? What does the cluster do when the Kyverno webhook stops answering and its failure policy is set to fail closed? A `verifyImages` rule rewrote a tag to a digest, and now the GitOps controller reports drift that never clears: what happened, and which side gives way? Level shows in where the answer stops. An early-career candidate is expected to write a rule that works and explain its match and exclude blocks, and the difference between Enforce and Audit. From senior level up the policy is a running system: rolling a rule from audit to blocking without breaking the workloads that already violate it, deciding who may create a `PolicyException`, and reading a report backlog nobody has worked in months. Recent releases deprecate `ClusterPolicy` in favour of policy types written in CEL, so a team in the middle of that migration may ask what changes when a deny condition becomes an expression.
Nothing specific to Kyverno appears until the fourth group, and the delay is deliberate. The first stretch is engine-neutral: how a [declarative match document](/topics/sec-policy-as-code-fundamentals-decision-model-language-styles) differs from rules written in a logic or expression language, what an engine can see beyond the change itself, and what [audit, warn and enforce](/topics/sec-policy-as-code-fundamentals-enforcement-placement-audit-warn-enforce) each do to a violation. The Kubernetes objects that rules select come next, because a match block is only as precise as your grasp of [labels and selectors](/topics/cloud-kubernetes-api-objects-labels-selectors), of [owner references](/topics/cloud-kubernetes-api-objects-ownership-gc), and of the [Pod templates](/topics/cloud-kubernetes-pods-workloads-deployments) that controllers stamp out. [Admission control](/topics/sec-policy-as-code-k8s-admission) then shows what the API server hands an engine and what it never hands it, with [webhook registration](/topics/cloud-kubernetes-operators-crds-admission-webhooks) explaining how Kyverno sits in that path at all. Kyverno's own rules start with validation, the form most interviews begin with: how [a policy selects](/topics/sec-policy-as-code-kyverno-validating-policy-structure) the resources it judges, how a [pattern](/topics/sec-policy-as-code-kyverno-validating-pattern-anchors) describes the shape a resource must have and where a misplaced anchor quietly admits everything, and when a deny condition over request fields says what a pattern cannot. [Autogen](/topics/sec-policy-as-code-kyverno-validating-controller-autogen) closes the stretch because it reuses everything about Pods and their controllers. [Mutation and generation](/topics/sec-policy-as-code-kyverno-mutate-generate) follow, where a policy changes or creates objects instead of judging them. Image verification waits until then for two reasons. It needs the signing model first, which is why the stretch opens on [cosign](/topics/sec-supply-chain-signing-cosign-flow) and on [whose signature to accept](/topics/sec-supply-chain-signing-trust-policy) before Kyverno's [attestor rules](/topics/sec-policy-as-code-kyverno-validating-image-verification). And its rewrite of a tag to a digest is itself a mutation, easier to reason about once mutation is familiar. The plan ends where a rule meets real clusters: [reports and exceptions](/topics/sec-policy-as-code-kyverno-evidence-exemptions), then [testing a rule](/topics/sec-policy-as-code-lifecycle-operations-authoring) with near-miss cases, surviving [engine upgrades](/topics/sec-policy-as-code-lifecycle-operations-runtime-platform-upgrades), and [rolling enforcement out](/topics/cloud-kubernetes-security-admission-policy) across teams that did not ask for it.
A cluster administrator meeting policy engines for the first time can skim the Kubernetes objects and spend the early hours on the first stretch and on admission, since many wrong Kyverno answers turn out to be wrong about what the request contains. A security engineer who knows the threat but not Kubernetes should do the reverse and go slowly through the objects, because autogen and generate questions are really questions about controllers and owners. With a week or two, narrow level to the band you are interviewing at and raise importance to must know; then give the validate rules the most time, because live exercises are usually built on them. With longer, switch study order to by topics and work the plan through, writing each rule you study into a test cluster and running the CLI's `kyverno test` against a pass case and a near-miss. This plan is about one engine. Interviewers often set Rego and OPA Gatekeeper beside it, and policy checks also run in pipelines long before admission; the [Policy as Code roadmap](/roadmaps/policy-as-code) covers both. For the cluster itself, scheduling, networking and storage, go to the [Kubernetes roadmap](/roadmaps/kubernetes).
Kyverno is asked about where a team already runs it: in the Kubernetes or cluster-security round of a platform, DevOps, SRE or DevSecOps loop, and sometimes as a live exercise in which you write a policy on the spot, one that requires resource limits or refuses images tagged latest. Interviewers usually read the policy back to you and ask what it actually lets through.
The questions are about behaviour that surprises people in production. A rule matches only Pods, so why does it refuse a Deployment, and why does the same violation inside a CronJob slip past? Why does a pattern with an anchor on the wrong key admit every container? What does the cluster do when the Kyverno webhook stops answering and its failure policy is set to fail closed? A verifyImages rule rewrote a tag to a digest, and now the GitOps controller reports drift that never clears: what happened, and which side gives way?
Level shows in where the answer stops. An early-career candidate is expected to write a rule that works and explain its match and exclude blocks, and the difference between Enforce and Audit. From senior level up the policy is a running system: rolling a rule from audit to blocking without breaking the workloads that already violate it, deciding who may create a PolicyException, and reading a report backlog nobody has worked in months. Recent releases deprecate ClusterPolicy in favour of policy types written in CEL, so a team in the middle of that migration may ask what changes when a deny condition becomes an expression.
Nothing specific to Kyverno appears until the fourth group, and the delay is deliberate. The first stretch is engine-neutral: how a declarative match document differs from rules written in a logic or expression language, what an engine can see beyond the change itself, and what audit, warn and enforce each do to a violation. The Kubernetes objects that rules select come next, because a match block is only as precise as your grasp of labels and selectors, of owner references, and of the Pod templates that controllers stamp out. Admission control then shows what the API server hands an engine and what it never hands it, with webhook registration explaining how Kyverno sits in that path at all.
Kyverno's own rules start with validation, the form most interviews begin with: how a policy selects the resources it judges, how a pattern describes the shape a resource must have and where a misplaced anchor quietly admits everything, and when a deny condition over request fields says what a pattern cannot. Autogen closes the stretch because it reuses everything about Pods and their controllers. Mutation and generation follow, where a policy changes or creates objects instead of judging them.
Image verification waits until then for two reasons. It needs the signing model first, which is why the stretch opens on cosign and on whose signature to accept before Kyverno's attestor rules. And its rewrite of a tag to a digest is itself a mutation, easier to reason about once mutation is familiar. The plan ends where a rule meets real clusters: reports and exceptions, then testing a rule with near-miss cases, surviving engine upgrades, and rolling enforcement out across teams that did not ask for it.
A cluster administrator meeting policy engines for the first time can skim the Kubernetes objects and spend the early hours on the first stretch and on admission, since many wrong Kyverno answers turn out to be wrong about what the request contains. A security engineer who knows the threat but not Kubernetes should do the reverse and go slowly through the objects, because autogen and generate questions are really questions about controllers and owners.
With a week or two, narrow level to the band you are interviewing at and raise importance to must know; then give the validate rules the most time, because live exercises are usually built on them. With longer, switch study order to by topics and work the plan through, writing each rule you study into a test cluster and running the CLI's kyverno test against a pass case and a near-miss.
This plan is about one engine. Interviewers often set Rego and OPA Gatekeeper beside it, and policy checks also run in pipelines long before admission; the Policy as Code roadmap covers both. For the cluster itself, scheduling, networking and storage, go to the Kubernetes roadmap.