Política como código — OPA, Rego e enforcer automático de regras

Política como código (Policy as Code) transforma regras de segurança — que costumam existir apenas em documentos — em código executável, testável e versionado. O Open Policy Agent (OPA) com a linguagem Rego é o padrão mais adotado para isso.

O que é OPA

OPA é um motor de política de propósito geral, desacoplado da aplicação. Ele recebe uma entrada JSON (o que está acontecendo), consulta uma política Rego (o que é permitido) e devolve uma decisão (permitir/negar).

Arquitetura OPA:

  Aplicação / pipeline
       │  input (JSON)
       ▼
    ┌─────┐
    │ OPA │  ←── política (.rego)
    └─────┘
       │  resultado: { "allow": true } ou { "allow": false, "reasons": [...] }
       ▼
  Aplicação age conforme a decisão

Linguagem Rego — conceitos básicos

# policy/deny_root.rego
package kubernetes.admission

import future.keywords.if
import future.keywords.contains

# Nega pods que rodam como root
deny contains msg if {
    input.request.kind.kind == "Pod"
    container := input.request.object.spec.containers[_]
    container.securityContext.runAsUser == 0
    msg := sprintf("Container '%v' não pode rodar como root (UID 0)", [container.name])
}

# policy/require_labels.rego
package kubernetes.admission

# Exige labels obrigatórias em todos os Deployments
deny contains msg if {
    input.request.kind.kind == "Deployment"
    required_labels := {"owner", "env", "cost-center"}
    existing := {l | input.request.object.metadata.labels[l]}
    missing := required_labels - existing
    count(missing) > 0
    msg := sprintf("Labels obrigatórias ausentes: %v", [missing])
}

OPA no Kubernetes — Gatekeeper

O Gatekeeper integra OPA como admission controller do Kubernetes: qualquer recurso criado ou alterado passa pelas políticas antes de ser aceito.

# ConstraintTemplate — define o tipo de restrição
apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8srequiredlabels
spec:
  crd:
    spec:
      names:
        kind: K8sRequiredLabels
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequiredlabels
        violation[{"msg": msg}] {
          required := input.parameters.labels[_]
          not input.review.object.metadata.labels[required]
          msg := sprintf("Label obrigatória ausente: %v", [required])
        }
---
# Constraint — aplica a regra a Namespaces
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequiredLabels
metadata:
  name: ns-must-have-owner
spec:
  match:
    kinds:
      - apiGroups: [""]
        kinds: ["Namespace"]
  parameters:
    labels: ["owner", "env"]

OPA no pipeline de CI/CD

Políticas podem ser avaliadas antes mesmo do deploy, durante o pipeline:

# Avaliar manifesto Kubernetes contra política OPA
opa eval \
  --input k8s/deployment.yaml \
  --data policy/ \
  --format pretty \
  'data.kubernetes.admission.deny'

# Se deny retornar resultados não-vazios → pipeline falha

# GitHub Actions — OPA conftest
- name: Policy check with conftest
  run: |
    conftest test k8s/ --policy policy/ --all-namespaces
  # conftest é um wrapper CLI para OPA, suporta múltiplos formatos:
  # Terraform, Kubernetes YAML, Dockerfile, JSON, TOML

Casos de uso práticos

Kubernetes / Gatekeeper:
  - Bloquear imagens sem digest fixo (somente sha256)
  - Exigir resource limits em todos os containers
  - Proibir hostNetwork: true e hostPID: true
  - Negar pods sem readinessProbe

Pipeline CI/CD:
  - Bloquear deploy para prod sem aprovação de segurança
  - Exigir que imagens venham apenas de registries autorizados
  - Negar Terraform com security group 0.0.0.0/0

API Gateway / Envoy:
  - Autorização de requisições com base em claims do JWT
  - Rate limiting por tenant

Testando políticas

Políticas como código têm testes automatizados:

# policy/deny_root_test.rego
package kubernetes.admission_test

test_deny_root_container if {
    result := deny with input as {
        "request": {
            "kind": {"kind": "Pod"},
            "object": {"spec": {"containers": [
                {"name": "app", "securityContext": {"runAsUser": 0}}
            ]}}
        }
    }
    count(result) > 0
}

opa test policy/ -v
# PASS: test_deny_root_container

Resumo

OPA e Rego permitem que políticas de segurança sejam versionadas, revisadas em PR, testadas automaticamente e aplicadas de forma consistente em Kubernetes, pipelines e APIs. Substituem documentos de conformidade por código executável — a política falha ou passa, sem ambiguidade.