🟡 Intermediate

Policy-as-Code — Automatizovaný enforcement pravidiel

Policy-as-Code je prístup, kde bezpečnostné, compliance a operačné pravidlá definujete ako kód — verzionovaný, testovateľný a automaticky vynucovaný. Namiesto manuálnych auditov a checklist dokumentov máte politiky, ktoré sa vyhodnocujú pri každom deployi, pull requeste alebo zmene infraštruktúry.

Čo je Policy-as-Code a prečo ho potrebujeme

V tradičnom modeli bezpečnostný tím napíše dokument s pravidlami (žiadne kontajnery ako root, povinné labely, šifrovanie at rest) a dúfa, že ich vývojári dodržia. Realita je iná — pravidlá sa porušujú, audity odhaľujú problémy neskoro a náprava je drahá.

Policy-as-Code tento problém rieši:

  • Deklaratívne pravidlá — politiky sú zapísané v štruktúrovanom jazyku (Rego, YAML, HCL)
  • Automatický enforcement — porušenie sa zachytí v CI/CD pipeline alebo admission controlleri
  • Verzionovanie — politiky žijú v Git repozitári s plnou históriou zmien
  • Testovateľnosť — politiky sa dajú unit testovať rovnako ako aplikačný kód
  • Audit trail — každá zmena politiky má autora, review a timestamp

Manuálny audit vs automatizovaný enforcement

Aspekt Manuálny audit Policy-as-Code
Rýchlosť Dni až týždne Sekundy
Pokrytie Vzorka 100 % zdrojov
Konzistencia Závisí od audítora Deterministické
Frekvencia Kvartálne/ročne Pri každej zmene
Škálovateľnosť Lineárna s tímom Automatická

Prehľad nástrojov

Open Policy Agent (OPA) / Rego

OPA je open-source, CNCF graduated policy engine. Politiky sa píšu v jazyku Rego — deklaratívnom query jazyku inšpirovanom Datalogom. OPA je univerzálny — funguje pre Kubernetes, API autorizáciu, Terraform, CI/CD aj mikroslužby.

# Zakázať kontajnery bežiace ako root
package kubernetes.admission

deny[msg] {
    input.request.kind.kind == "Pod"
    container := input.request.object.spec.containers[_]
    container.securityContext.runAsUser == 0
    msg := sprintf("Kontajner '%s' nesmie bežať ako root", [container.name])
}

Kedy použiť: Univerzálne nasadenie, multi-platform prostredia, pokročilé pravidlá vyžadujúce Rego.

Kyverno

Kubernetes-natívny policy engine. Politiky sú čisté Kubernetes YAML — žiadny nový jazyk. Podporuje validáciu, mutáciu aj generovanie zdrojov. Pre Kubernetes tímy je to najrýchlejší štart.

Kedy použiť: Čisto Kubernetes prostredia, tímy ktoré nechcú učiť Rego.

HashiCorp Sentinel

Komerčný policy framework od HashiCorp. Natívna integrácia s Terraform Cloud/Enterprise, Vault a Consul. Politiky sa píšu v jazyku Sentinel (Python-like syntax).

# Sentinel: Zakázať verejné S3 buckety
import "tfplan/v2" as tfplan

s3_buckets = filter tfplan.resource_changes as _, rc {
    rc.type is "aws_s3_bucket" and
    rc.change.actions contains "create"
}

main = rule {
    all s3_buckets as _, bucket {
        bucket.change.after.acl is not "public-read"
    }
}

Kedy použiť: Terraform Cloud/Enterprise zákazníci, HashiCorp ekosystém.

Checkov

Open-source statický analyzátor pre IaC. Skenuje Terraform, CloudFormation, Kubernetes manifesty, Helm charty a Dockerfiles. Obsahuje 1000+ vstavaných pravidiel mapovaných na CIS benchmarky a compliance frameworky.

Kedy použiť: Rýchly štart pre IaC scanning, CI/CD integrácia, compliance reporting.

AWS Config Rules

AWS-natívna služba na vyhodnocovanie konfigurácie AWS zdrojov. Podporuje managed rules (predpripravené) aj custom rules (Lambda funkcie). Kontinuálne monitoruje compliance stav.

Kedy použiť: AWS-only prostredia, natívna integrácia s AWS ekosystémom.

Policy-as-Code v Kubernetes

Admission Controllers

Kubernetes admission controllers sú brána medzi API requestom a uložením objektu do etcd. Policy enginy sa pripájajú ako validating/mutating admission webhooky.

Tok requestu:

  1. Používateľ pošle kubectl apply
  2. API server prijme request
  3. Mutating webhooks — môžu zmeniť objekt (pridať labely, inject sidecar)
  4. Validating webhooks — schvália alebo zamietnu objekt
  5. Objekt sa uloží do etcd

Kyverno policies — praktické príklady

Povinné labely na každom Pode

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: require-labels
spec:
  validationFailureAction: Enforce
  rules:
    - name: require-team-label
      match:
        any:
          - resources:
              kinds:
                - Pod
      validate:
        message: "Label 'team' je povinný na každom Pode."
        pattern:
          metadata:
            labels:
              team: "?*"

Zakázať privilegované kontajnery

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: disallow-privileged
spec:
  validationFailureAction: Enforce
  rules:
    - name: no-privileged-containers
      match:
        any:
          - resources:
              kinds:
                - Pod
      validate:
        message: "Privilegované kontajnery nie sú povolené."
        pattern:
          spec:
            containers:
              - securityContext:
                  privileged: "false"

Automatické pridanie resource limitov (mutácia)

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: add-default-resources
spec:
  rules:
    - name: add-memory-limit
      match:
        any:
          - resources:
              kinds:
                - Pod
      mutate:
        patchStrategicMerge:
          spec:
            containers:
              - (name): "*"
                resources:
                  limits:
                    memory: "512Mi"
                  requests:
                    memory: "128Mi"

OPA Gatekeeper

OPA Gatekeeper je Kubernetes-natívna integrácia OPA. Používa CRD — ConstraintTemplate definuje logiku a Constraint ju aplikuje.

apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8srequiredlabels
spec:
  crd:
    spec:
      names:
        kind: K8sRequiredLabels
      validation:
        openAPIV3Schema:
          type: object
          properties:
            labels:
              type: array
              items:
                type: string
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequiredlabels
        violation[{"msg": msg}] {
          provided := {label | input.review.object.metadata.labels[label]}
          required := {label | label := input.parameters.labels[_]}
          missing := required - provided
          count(missing) > 0
          msg := sprintf("Chýbajúce povinné labely: %v", [missing])
        }
---
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequiredLabels
metadata:
  name: pods-must-have-team
spec:
  match:
    kinds:
      - apiGroups: [""]
        kinds: ["Pod"]
  parameters:
    labels: ["team", "environment"]

Policy-as-Code v CI/CD pipeline

Integrácia politík do CI/CD pipeline posúva enforcement ešte skôr — shift-left. Problém sa zachytí v pull requeste, nie až pri deployi.

Conftest — OPA pre CI/CD

Conftest je CLI nástroj na vyhodnocovanie OPA politík voči štruktúrovaným dátam (YAML, JSON, HCL, Dockerfile).

# Inštalácia
brew install conftest

# Spustenie testov
conftest test deployment.yaml --policy policy/

# Výstup
FAIL - deployment.yaml - Kontajner 'app' nesmie bežať ako root
FAIL - deployment.yaml - Chýba label 'team'

2 test failures

GitHub Actions integrácia

name: Policy Check
on: [pull_request]

jobs:
  policy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install Conftest
        run: |
          wget -q https://github.com/open-policy-agent/conftest/releases/download/v0.50.0/conftest_0.50.0_Linux_x86_64.tar.gz
          tar xzf conftest_*.tar.gz
          sudo mv conftest /usr/local/bin/

      - name: Run policy checks
        run: conftest test k8s/ --policy policy/ --output json

      - name: Checkov IaC scan
        uses: bridgecrewio/checkov-action@v12
        with:
          directory: terraform/
          framework: terraform
          soft_fail: false

GitLab CI integrácia

policy-check:
  stage: validate
  image: openpolicyagent/conftest:latest
  script:
    - conftest test k8s/ --policy policy/ --all-namespaces
  rules:
    - changes:
        - k8s/**/*
        - policy/**/*

Policy-as-Code pre IaC

Sentinel pre Terraform

Sentinel sa vyhodnocuje v Terraform Cloud/Enterprise medzi plan a apply. Tri úrovne enforcement:

  • advisory — upozornenie, apply pokračuje
  • soft-mandatory — blokuje, ale override je možný
  • hard-mandatory — blokuje bez výnimky
# Vyžadovať tagy na všetkých EC2 inštanciách
import "tfplan/v2" as tfplan

ec2_instances = filter tfplan.resource_changes as _, rc {
    rc.type is "aws_instance"
}

required_tags = ["Environment", "Owner", "CostCenter"]

main = rule {
    all ec2_instances as _, instance {
        all required_tags as tag {
            instance.change.after.tags contains tag
        }
    }
}

Checkov a tfsec

# Checkov — sken Terraform kódu
checkov -d terraform/ --framework terraform

# Výstup
Passed checks: 42, Failed checks: 3, Skipped checks: 0

Check: CKV_AWS_18: "Ensure the S3 bucket has access logging enabled"
  FAILED for resource: aws_s3_bucket.data
  File: /main.tf:15-25

# tfsec — alternatíva (teraz súčasť Trivy)
trivy config terraform/

OPA pre Terraform (bez Sentinel)

Pre tímy používajúce open-source Terraform existuje Conftest workflow:

# Vygeneruj JSON plan
terraform plan -out=tfplan
terraform show -json tfplan > tfplan.json

# Vyhodnoť politiky
conftest test tfplan.json --policy policy/terraform/

# policy/terraform/s3.rego
package terraform.s3

deny[msg] {
    resource := input.resource_changes[_]
    resource.type == "aws_s3_bucket"
    resource.change.after.versioning[0].enabled != true
    msg := sprintf("S3 bucket '%s' musí mať zapnuté versioning", [resource.name])
}

Compliance a legislatíva

Policy-as-Code nie je len o best practices — čoraz viac je aj o právnych požiadavkách.

NIS2 (Network and Information Security Directive)

NIS2 direktíva EÚ (účinná od októbra 2024) vyžaduje:

  • Riadenie rizík — organizácie musia implementovať technické opatrenia na riadenie kybernetických rizík
  • Incident reporting — povinné hlásenie incidentov do 24 hodín
  • Supply chain security — kontrola bezpečnosti dodávateľského reťazca
  • Pravidelné audity — preukázateľná compliance

Policy-as-Code pomáha:

  • Automatizovaný audit infraštruktúry = preukázateľná compliance
  • Git história politík = dôkaz o implementácii opatrení
  • Kontinuálne vyhodnocovanie = nie len raz ročne

EU Cyber Resilience Act (CRA)

CRA zavádza povinné bezpečnostné požiadavky pre digitálne produkty:

  • Secure by default — produkty musia byť bezpečné v predvolenom nastavení
  • Vulnerability management — povinný proces na správu zraniteľností
  • SBOM — povinný Software Bill of Materials

Policy-as-Code dokáže automaticky vynucovať:

  • Žiadne known vulnerabilities v kontajner images (Trivy/Grype scan)
  • Povinné security kontexty na všetkých workloadoch
  • SBOM generovanie v CI/CD pipeline
  • Šifrovanie at rest a in transit

Mapovanie politík na compliance frameworky

CIS Kubernetes Benchmark 5.2.1  →  Kyverno: disallow-privileged
CIS Kubernetes Benchmark 5.2.6  →  Kyverno: disallow-host-namespaces
NIS2 Article 21(2)(a)           →  OPA: require-encryption-at-rest
CRA Annex I, Section 1(3)(a)    →  Checkov: CKV_DOCKER_3 (no HEALTHCHECK)

Best Practices

1. Warn → Enforce rollout

Nikdy nezačínajte s Enforce na produkčnom klastri. Postup:

  1. Audit mode — politika loguje porušenia, ale neblokuje
  2. Warn — používatelia dostanú upozornenie, deploy prejde
  3. Enforce na dev/staging — blokuje na neprodukčných prostrediach
  4. Enforce na produkcii — až keď sú všetky existujúce porušenia vyriešené
# Kyverno: Začnite s Audit
spec:
  validationFailureAction: Audit
  # Neskôr zmeňte na:
  # validationFailureAction: Enforce

2. Policy testing

Politiky sú kód — testujte ich:

# OPA unit testy
opa test policy/ -v

# Kyverno CLI testy
kyverno test tests/

# Kyverno test súbor
apiVersion: cli.kyverno.io/v1alpha1
kind: Test
metadata:
  name: test-require-labels
policies:
  - ../policies/require-labels.yaml
resources:
  - resources.yaml
results:
  - policy: require-labels
    rule: require-team-label
    resource: pod-with-label
    result: pass
  - policy: require-labels
    rule: require-team-label
    resource: pod-without-label
    result: fail

3. GitOps pre policies

Uložte politiky do Git repozitára a nasadzujte ich cez ArgoCD/Flux:

  • Verzionované politiky — každá zmena má PR review
  • Automatická synchronizácia — GitOps agent aplikuje zmeny
  • Rollback — revert commit = rollback politiky
  • Multi-cluster konzistencia — rovnaké politiky na všetkých klastroch

4. Exceptions a escape hatches

Vždy majte mechanizmus na výnimky — niektoré workloady legitimne potrebujú privilegovaný prístup (monitoring agenty, CNI pluginy):

# Kyverno: exclude systémové namespacy
spec:
  rules:
    - name: no-privileged
      exclude:
        any:
          - resources:
              namespaces:
                - kube-system
                - monitoring

5. Dokumentácia a onboarding

  • Ku každej politike napíšte zrozumiteľný message s vysvetlením prečo a ako problém opraviť
  • Vytvorte katalóg politík s príkladmi
  • Nastavte Slack/Teams notifikácie pre nové politiky

6. Metriky a reporting

Sledujte efektívnosť politík:

  • Počet blokovaných deploymentov za deň/týždeň
  • Top 5 najčastejšie porušovaných politík
  • Čas na opravu porušenia
  • Pomer warn vs enforce politík

Policy-as-Code je základný stavebný blok moderného DevSecOps. Začnite s jednoduchými politikami, postupne pridávajte komplexnejšie pravidlá a vždy testujte pred enforcement. Kombinácia s GitOps prístupom vám dá plnú auditovateľnosť a kontrolu nad celou infraštruktúrou.