OPA Gatekeeper: Admission Controller für Kubernetes

TL;DR

OPA Gatekeeper ist ein Kubernetes Admission Controller, der Deployments gegen definierte Policies prüft, bevor sie im Cluster landen. Mit ConstraintTemplates schreiben Sie wiederverwendbare Regeln in Rego - etwa Pflicht-Labels, Verbot privilegierter Container oder erzwungene Resource Limits. Die Alternative Kyverno ist einfacher, Gatekeeper dafür mächtiger.

Gatekeeper installieren

Die Installation erfolgt per Helm in wenigen Schritten:

# Helm Repo hinzufügen
helm repo add gatekeeper https://open-policy-agent.github.io/gatekeeper/charts
helm repo update

# Gatekeeper installieren
helm install gatekeeper gatekeeper/gatekeeper \
  --namespace gatekeeper-system --create-namespace \
  --set replicas=3 \
  --set audit.replicas=1

# Pods prüfen
kubectl get pods -n gatekeeper-system

Gatekeeper registriert sich automatisch als ValidatingAdmissionWebhook. Jede API-Anfrage durchläuft ab sofort die Policy-Prüfung.

So funktioniert Gatekeeper

Gatekeeper nutzt zwei Kubernetes-CRDs:

ConstraintTemplate - Definiert die Policy-Logik in Rego
Constraint - Wendet die Policy auf bestimmte Ressourcen an

API Request → Admission Webhook → Gatekeeper → Rego Policy
                                      ↓
                              Allow oder Deny

Policy 1: Pflicht-Labels erzwingen

Jedes Deployment braucht ein team-Label. Ohne Label wird das Deployment abgelehnt.

ConstraintTemplate

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("Fehlende Labels: %v", [missing])
        }

Constraint anwenden

apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequiredLabels
metadata:
  name: require-team-label
spec:
  match:
    kinds:
      - apiGroups: ["apps"]
        kinds: ["Deployment"]
    namespaces: ["production", "staging"]
  parameters:
    labels: ["team", "app"]

Test:

# Wird abgelehnt - fehlende Labels
kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-app
  namespace: production
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test
  template:
    metadata:
      labels:
        app: test
    spec:
      containers:
      - name: nginx
        image: nginx:1.27
EOF
# Error: Fehlende Labels: {"team"}

Policy 2: Privilegierte Container blockieren

apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8sblockprivileged
spec:
  crd:
    spec:
      names:
        kind: K8sBlockPrivileged
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8sblockprivileged

        violation[{"msg": msg}] {
          container := input.review.object.spec.template.spec.containers[_]
          container.securityContext.privileged == true
          msg := sprintf("Privilegierter Container nicht erlaubt: %v", [container.name])
        }

        violation[{"msg": msg}] {
          container := input.review.object.spec.template.spec.initContainers[_]
          container.securityContext.privileged == true
          msg := sprintf("Privilegierter Init-Container nicht erlaubt: %v", [container.name])
        }
---
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sBlockPrivileged
metadata:
  name: block-privileged-containers
spec:
  match:
    kinds:
      - apiGroups: ["apps"]
        kinds: ["Deployment", "StatefulSet", "DaemonSet"]
    excludedNamespaces: ["kube-system", "falco"]

Policy 3: Resource Limits erzwingen

apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8srequireresources
spec:
  crd:
    spec:
      names:
        kind: K8sRequireResources
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequireresources

        violation[{"msg": msg}] {
          container := input.review.object.spec.template.spec.containers[_]
          not container.resources.limits.memory
          msg := sprintf("Memory Limit fehlt für Container: %v", [container.name])
        }

        violation[{"msg": msg}] {
          container := input.review.object.spec.template.spec.containers[_]
          not container.resources.limits.cpu
          msg := sprintf("CPU Limit fehlt für Container: %v", [container.name])
        }

        violation[{"msg": msg}] {
          container := input.review.object.spec.template.spec.containers[_]
          not container.resources.requests.memory
          msg := sprintf("Memory Request fehlt für Container: %v", [container.name])
        }

Audit-Modus: Policies testen ohne zu blockieren

Bevor Sie Policies scharf schalten, testen Sie im Audit-Modus. Gatekeeper prüft dann bestehende Ressourcen und meldet Verstöße, blockiert aber nichts:

apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequiredLabels
metadata:
  name: require-team-label
spec:
  enforcementAction: dryrun   # warn | deny | dryrun
  match:
    kinds:
      - apiGroups: ["apps"]
        kinds: ["Deployment"]

Verstöße anzeigen:

# Alle Violations auflisten
kubectl get k8srequiredlabels require-team-label -o yaml | \
  grep -A 50 "violations:"

# Gatekeeper Audit-Logs prüfen
kubectl logs -n gatekeeper-system -l control-plane=audit-controller

Gatekeeper vs. Kyverno

Eigenschaft	Gatekeeper	Kyverno
Policy-Sprache	Rego (eigene Sprache)	YAML (nativ Kubernetes)
Lernkurve	Steil - Rego muss erlernt werden	Flach - reines YAML
Flexibilität	Sehr hoch, komplexe Logik möglich	Gut für Standardfälle
Mutating	Eingeschränkt (Assign/Modify)	Ja, nativ unterstützt
Generate	Nein	Ja, kann Ressourcen erzeugen
Community	CNCF Graduated, große Adoption	CNCF Incubating, wächst schnell

Empfehlung: Kyverno für Teams, die schnell starten wollen. Gatekeeper für Umgebungen mit komplexen Policy-Anforderungen oder wenn Rego-Expertise bereits vorhanden ist.

Gatekeeper Policy Library

Statt jede Policy selbst zu schreiben, nutzen Sie die offizielle Bibliothek:

# Gatekeeper Library klonen
git clone https://github.com/open-policy-agent/gatekeeper-library.git

# Beispiel: Alle Container brauchen Image-Tag (kein :latest)
kubectl apply -f gatekeeper-library/library/general/disallowedtags/template.yaml

Die Library enthält fertige ConstraintTemplates für die häufigsten Anforderungen: Image Policies, Network Policies, Pod Security Standards und mehr.

FAQ

Verlangsamt Gatekeeper meine Deployments?

Minimal. Die Webhook-Prüfung dauert typischerweise unter 10ms. Bei sehr vielen ConstraintTemplates kann die Latenz steigen - überwachen Sie die Webhook-Latenz mit Prometheus.

Was passiert, wenn Gatekeeper ausfällt?

Standardmäßig ist der Webhook als failPolicy: Ignore konfiguriert. Bei Ausfall werden Requests durchgelassen. Für strenge Umgebungen können Sie failPolicy: Fail setzen, dann blockiert ein Ausfall alle Deployments.

Kann Gatekeeper auch bestehende Ressourcen prüfen?

Ja, der Audit-Controller prüft regelmäßig alle bestehenden Ressourcen gegen aktive Constraints. Verstöße werden im Status der Constraint-Ressource gemeldet.

Wie debugge ich eine fehlgeschlagene Rego-Policy?

Nutzen Sie den OPA Playground (play.openpolicyagent.org) zum Testen. Lokal können Sie opa eval mit Test-Input verwenden. Gatekeeper-Logs zeigen ebenfalls detaillierte Fehlermeldungen.

Lässt sich Gatekeeper mit GitOps kombinieren?

Ja, ConstraintTemplates und Constraints sind normale Kubernetes-Ressourcen. Verwalten Sie sie in Git und deployen Sie über ArgoCD oder Flux - Policy as Code im besten Sinne.

Kubernetes-Security & Compliance?

Security-Audits, Penetration Tests und Compliance-Beratung für Ihre Container-Infrastruktur. BSI-Grundschutz, DSGVO, ISO 27001.

Security-Assessment anfragen Kontakt aufnehmen