Unsichere Kubernetes-Systeme absichern

Unsichere Systeme sind eine tickende Zeitbombe in Kubernetes-Umgebungen. Fehlerhafte Konfigurationen, veraltete Images oder unzureichende Ressourcenbegrenzungen bieten eine breite Angriffsfläche. In diesem dritten Teil unserer Serie zu Kubernetes Security zeigen wir Ihnen, wie Sie mit den richtigen Tools und Best Practices Ihre Umgebung absichern und automatisieren können.

Sie steigen gerade erst ein? Hier finden Sie Teil 1 und 2 dieser Serie sowie das Video des Webcasts, auf dem die Serie aufbaut:

Teil 1: Kubernetes-Sicherheit im Fokus: Best Practices und Strategie

Teil 2: Unerlaubte Zugriffe in Kubernetes – Ursachen, Risiken und Schutzmaßnahmen

Video: Kubernetes Security Webcast

Schwachstellen frühzeitig erkennen und beheben

Mit automatisierte Schwachstellenscans und Ressourcenlimits und Quotas können Sie viel für die Sicherheit Ihrer Systeme erreichen. Aber bei der Aufsetzung ist einiges zu beachten. Darum geht es:

1. Automatisierte Schwachstellenscans

Container Scanning und Sicherheitsrichtlinien:
Manuelles Überprüfen ist ineffizient – automatisierte Tools wie Trivy oder Clair bieten hier entscheidende Vorteile. Sie scannen Container-Images auf bekannte Sicherheitslücken und lassen sich in CI/CD-Pipelines integrieren:

Beispiel für Trivy in einer Pipeline:

scan:
  stage: security 
  image:  aquasec/trivy:latest 
  script:  
    - trivy image my-image:latest

Ergänzend dazu hilft Kubescape, Sicherheitsrichtlinien auf Clusterebene zu überprüfen, indem es ermöglicht den Cluster gegen verschiedene Sicherheitsframeworks zu testen.

Kubescape bietet bisher Unterstützung für folgende Frameworks:

NSA – basiert auf dem Kubernetes Hardening Guide der NSA und CISA
MITRE – basiert auf dem MITRE ATT&CK® Framework
CIS – basiert auf den CIS Benchmarks für Kubernetes und ist in drei Varianten vertreten: für Standard Kubernetes, und für Managed Kubernetes jeweils in Azure oder in AWS

Eine Auflistung der unterstützen Frameworks kann über folgenden Aufruf angezeigt werden:

kubescape list frameworks

Es ist ebenfalls möglich mit einem Aufruf auf unterschiedlichen Frameworks zu testen. Dazu werden die Frameworks kommasepariert im Scan-Befehl aufgeführt:

kubescape scan framework nsa,mitre,cis-v1.23-t1.0.1

HELM Chart Scanning:
Nicht nur Container-Images, sondern auch HELM Charts können Schwachstellen enthalten. Tools wie Trivy oder Checkov helfen, fehlerhafte oder unsichere Konfigurationen zu erkennen.

Trivy für HELM Chart Scans:

trivy config /path/to/helm/chart

Checkov für Infrastructure-as-Code (IaC) Scans:

checkov -d /pfad/zu/helm/chart

In diesem Beispiel hat Checkov eine unsichere Konfiguration erkannt. Es fehlt eine SecurityContext-Konfiguration, was ein Sicherheitsrisiko darstellt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  template:
    spec:
      containers:
        - name: app
          image: my-image:latest

2. Ressourcenlimits und Quotas setzen

Unbegrenzte Ressourcen können den gesamten Cluster lahmlegen oder einen Denial-of-Service (DoS) durch fehlerhafte Pods verursachen. Kubernetes bietet zwei Mechanismen zur Begrenzung:

ResourceQuotas – Begrenzen die maximal nutzbaren Ressourcen von CPU, Memory und Storage innerhalb eines Namespace
LimitRanges – Definieren Default-Limits für einzelne Pods

ResourceQuota – Globale Limits für einen Namespace:
Mit ResourceQuotas kann verhindert werden, dass ein einzelner Namespace den Cluster monopolisiert.

Beispiel: ResourceQuota für CPU und Speicher

apiVersion: v1
kind:  ResourceQuota 
metadata: 
  name:  compute-resources 
  namespace:  production 
spec: 
  hard: 
    requests.cpu:  "4" 
    requests.memory:  "8Gi" 
    limits.cpu:  "10" 
    limits.memory:  "16Gi"
    pods:  "20"

Erklärung:
requests.cpu/memory – Minimale garantierte Ressourcen
limits.cpu/memory – Maximale Nutzung pro Namespace
pods – Begrenzung der Gesamtanzahl an Pods

Warum ist das wichtig?
– Es wird verhindert, dass einzelne Teams zu viele Ressourcen beanspruchen.
– Es werden Obergrenzen gesetzt, um eine Überlastung des Clusters zu vermeiden.

LimitRange – Standardwerte für Pods setzen:
Während ResourceQuotas auf Namespace-Ebene arbeiten, ermöglichen LimitRanges, dass jeder Pod oder Container innerhalb eines Namespace Mindest- und Höchstwerte für CPU und RAM bekommt.

Beispiel – LimitRange für Container-Limits:

apiVersion: v1
kind: LimitRange
metadata:
  name: container-defaults
  namespace: production
spec:
  limits:
    - default:
        cpu: "500m"
        memory: "512Mi"
      defaultRequest:
        cpu: "200m"
        memory: "256Mi"
      type: Container

Erklärung:
default – Maximale Ressourcen, die ein Container erhalten kann.
defaultRequest – Standardanforderungen für neue Container.

Warum ist das wichtig?
– Erzwingt Limits, selbst wenn Entwickler sie nicht explizit setzen.
– Verhindert, dass ein Container den gesamten Namespace überlastet.

Sicherstellen der Limits mit Kyverno:
Tools wie Kyverno helfen, dass alle neuen Pods automatisch Limits enthalten, wenn sie nicht explizit gesetzt sind.

Beispiel – Kyverno Policy zur Erzwingung von Ressourcenlimits:

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: enforce-resource-limits
spec:
  validationFailureAction: Enforce
  rules:
    - name: check-container-resources
      match:
        resources:
          kinds:
            - Pod
      validate:
        message: "CPU und Memory Limits sind erforderlich!"
        pattern:
          spec:
            containers:
              - resources:
                  limits:
                    cpu: "?*"
                    memory: "?*"

Vorteile:
– Pods ohne CPU- oder Memory-Limits werden blockiert.
– Automatisiert die Durchsetzung von Best Practices.

Zusammenfassung

Automatisierte Scans und Ressourcenmanagement sind essenziell, um Schwachstellen und Sicherheitsrisiken zu minimieren und Cluster-Überlastung zu vermeiden. Setzen Sie auf Tools wie Trivy, Clair, Kubescape und Checkov, um proaktiv Sicherheitslücken zu erkennen, zu beheben und die Durchsetzung dieser Regeln zu automatisieren.

Mehr Sicherheit für Ihre Kubernetes-Umgebung!

Kubernetes bietet enorme Flexibilität – aber auch neue Angriffsflächen. In dieser Artikelserie zeigen wir, wie Sie Risiken minimieren und Ihre Cluster effektiv absichern.