roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Explain how Open Policy Agent decides and where its answers are enforced, from one Rego rule to a cluster webhook. Covers Rego, running and feeding OPA, conftest and Gatekeeper.
203 of 203 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 203 new. 0 cut, outside your plan.
Questions about Open Policy Agent arrive from two directions. Platform, DevSecOps and security engineering loops bring it in through the cluster and the pipeline, while backend loops reach it at teams that moved service authorization out of their own code. The usual exercise is a short Rego rule written live, such as denying a Pod whose image comes from an unapproved registry, followed by questions about how that rule reaches the place that enforces it.
The follow-ups are about behavior that surprises people. Why does a deny rule that reads a misspelled field never fire, and why is that a pass rather than an error? Why does a query to /v1/data come back as 200 with an empty body? What happens to every deployment in the cluster when the Gatekeeper webhook stops answering, and who chose that? Why can a Gatekeeper rule that checks for a sibling object block a change made seconds after that object was created?
What moves an answer up the levels is how far it travels from the rule. Early in a career, a rule that denies what it should and a test that proves it are the bar. Senior candidates are asked where the engine runs and what that placement costs: a sidecar in every Pod against one shared service, how a new bundle reaches all of them, what the decision log records, and how to keep a secret in the input out of it.
The plan starts with the half of the problem OPA does not solve. Policy engine fundamentals separate deciding from enforcing, the idea OPA is built on: it returns an answer and something else acts on it. Request-time attribute-based authorization sits beside it because outside the cluster OPA's most common job is answering a service that asks whether a caller may do something.
Rego comes before the engine, since every operational question later assumes you can read a rule. Its first part, how a rule resolves, explains undefined results, and its last, proving a rule, turns opa test into a habit before any rule is deployed.
Operating OPA then moves the rule into a running process. Where the engine runs sets up the decision API and the Envoy integration, and the second half covers what keeps it current: bundles with their revisions, context data, and the decision log. conftest follows as the smallest deployment of the same language: Rego run over files in a CI job, with an exit code as the enforcement.
The plan turns to Kubernetes in two steps. The admission stretch comes first because Gatekeeper is an admission webhook and inherits its limits: what the intercepted request carries and leaves out, how webhook registration decides what happens on a timeout, and how enforcement through admission compares with the built-in alternative and is rolled out across a cluster. Gatekeeper then reads as OPA packaged for that path: templates and constraints, audit for objects admitted before a rule existed, the replicated cache and offline testing with gator.
The closing stretch is about many rules across many engines: getting one version everywhere, proving the bundle that loaded is the one you published, and explaining a denial after the fact.
For a platform role on a cluster that runs Gatekeeper, the Rego, admission and Gatekeeper modules carry most of the weight; switching study order to by topics keeps the admission stretch ahead of the Gatekeeper questions that depend on it. A backend engineer using OPA for service authorization can go lighter on Kubernetes and spend the time on the decision API, Envoy and bundles. Short on time, the two controls worth changing are level, narrowed to the band you are applying at, and importance, raised to must know; keep Rego evaluation in the drill whatever else you cut, because a live exercise usually turns on it. Engineers who have only edited existing rules tend to know the syntax and not the engine around it. Run OPA locally as a server, push data through its API, and break a bundle on purpose before reading the operations questions. The plan teaches one engine and its integrations, not the wider practice. Gating a Terraform plan on its planned and unknown values, turning a compliance control into a check, and deciding who may override a blocking gate are covered by the [Policy as Code roadmap](/roadmaps/policy-as-code), which also takes in Kyverno. The cluster itself, from workloads to RBAC, belongs to the [Kubernetes roadmap](/roadmaps/kubernetes).
For a platform role on a cluster that runs Gatekeeper, the Rego, admission and Gatekeeper modules carry most of the weight; switching study order to by topics keeps the admission stretch ahead of the Gatekeeper questions that depend on it. A backend engineer using OPA for service authorization can go lighter on Kubernetes and spend the time on the decision API, Envoy and bundles. Short on time, the two controls worth changing are level, narrowed to the band you are applying at, and importance, raised to must know; keep Rego evaluation in the drill whatever else you cut, because a live exercise usually turns on it.
Engineers who have only edited existing rules tend to know the syntax and not the engine around it. Run OPA locally as a server, push data through its API, and break a bundle on purpose before reading the operations questions.
The plan teaches one engine and its integrations, not the wider practice. Gating a Terraform plan on its planned and unknown values, turning a compliance control into a check, and deciding who may override a blocking gate are covered by the Policy as Code roadmap, which also takes in Kyverno. The cluster itself, from workloads to RBAC, belongs to the Kubernetes roadmap.