Pass auf, ich hab es satt, immer wieder dieselben dummen Fehler zu sehen. Du fährst einen Cluster hoch, klatschst ein paar Manifeste zusammen und machst Feierabend. Sechs Monate später wunderst du dich, warum ein Cryptominer deine AWS-Rechnung auffrisst. Kubernetes ist im Standardzustand nicht sicher. Es ist eine geladene Waffe, die auf deine Produktionsumgebung zielt.
Unterm Strich: Wenn du diese 15 Fehlkonfigurationen nicht abriegelst, bettelst du förmlich darum, übernommen zu werden. Nehmen wir sie auseinander. Ich gehe hier tief rein, weil genau das Kratzen an der Oberfläche dich wegen eines massiven Datenlecks auf die Titelseite eines Tech-Blogs bringt.
Wir kennen das alle. Du willst eine Sprint-Deadline schaffen, also kopierst du einfach etwas YAML von Stack Overflow. Es funktioniert. Die App läuft. Du shippst es nach Prod. Aber unter der Haube ist dieses wackelige YAML eine tickende Zeitbombe. Die Realität der Kubernetes-Sicherheit 2026: Angreifer sind automatisiert. Sie sitzen nicht an einer Tastatur und tippen Befehle; sie haben Skripte, die das gesamte Internet nach exponierten API-Servern und offenen Ports scannen.
Das ist kein Spiel mehr. Wir haben es mit hochmotivierten Ransomware-Banden zu tun. Sie scannen nach offenen Kubelets. Sie nutzen RBAC-Fehlkonfigurationen in Sekunden aus. Gehen wir tiefer.
1. Privilegierte Container
Privilegierte Container laufen zu lassen heißt buchstäblich, Root-Zugriff auf den Host-Node zu verschenken. Hör damit auf. Mir ist egal, ob dein wackeliger Monitoring-Agent das braucht. Repariere den Agent. Wenn du privileged: true setzt, sagst du der Container-Runtime, dass sie alle Sicherheitsmechanismen abschalten soll. Seccomp? Weg. AppArmor? Ignoriert. Capabilities? Alle.
Ehrlich, es ist ein Albtraum. Ein Angreifer, der in einem privilegierten Container landet, kann einfach das Host-Dateisystem mounten, per chroot hineinwechseln und seine eigenen SSH-Keys auf dem Node hinterlegen. Game over. Du hast ihm gerade die Schlüssel zum Königreich übergeben.
Verwundbar:
apiVersion: v1
kind: Pod
metadata:
name: owned-pod
spec:
containers:
- name: app
image: nginx
securityContext:
privileged: trueGehärtet:
apiVersion: v1
kind: Pod
metadata:
name: secure-pod
spec:
containers:
- name: app
image: nginx
securityContext:
privileged: false
allowPrivilegeEscalation: false
capabilities:
drop:
- ALL2. hostPID
Den PID-Namespace des Hosts zu teilen heißt, dass dein Pod jeden Prozess auf dem Node sehen und mit ihm interagieren kann. Ein Angreifer bricht aus dem Pod aus und kann deinen Kubelet einfach per kill -9 abschießen oder Secrets aus anderen Prozessen stehlen.
Hat ein Angreifer RCE in einem Pod mit aktiviertem hostPID, kann er mit Tools wie nsenter in andere Namespaces springen. Er kann den Speicher laufender Prozesse dumpen. Läuft auf demselben Node ein Datenbankprozess, kann er Credentials direkt aus dem RAM ziehen. Ein gewaltiges Eigentor.
Verwundbar:
apiVersion: v1
kind: Pod
metadata:
name: snooper-pod
spec:
hostPID: true
containers:
- name: app
image: busyboxGehärtet:
apiVersion: v1
kind: Pod
metadata:
name: isolated-pod
spec:
hostPID: false
containers:
- name: app
image: busybox3. hostNetwork
Ähnlicher Müll. Du hängst den Pod in den Netzwerkraum des Nodes. Jetzt umgeht dein Pod Network Policies und kann den Traffic des Nodes mitschneiden. Weg damit.
Wenn ein Pod das Host-Netzwerk nutzt, bekommt er exakt denselben Netzwerkzugriff wie der Node selbst. Er umgeht alle Network Policies auf CNI-Ebene, die du mühsam eingerichtet hast. Ein Angreifer kann sich an localhost-Ports binden, die eigentlich geschützt sein sollten, etwa den Read-only-Port des Kubelets, oder mit tcpdump Traffic mitschneiden, der für andere Pods auf dem Node bestimmt ist. Ein Albtraum für die Netzwerkisolation.
Verwundbar:
apiVersion: v1
kind: Pod
metadata:
name: network-bypass
spec:
hostNetwork: trueGehärtet:
apiVersion: v1
kind: Pod
metadata:
name: network-isolated
spec:
hostNetwork: false4. Fehlende Network Policies
Standardmäßig ist K8s ein flaches Netzwerk. Jeder Pod kann mit jedem anderen Pod reden. Wird ein Web-Frontend gehackt, kann der Angreifer einfach per curl deine Backend-Datenbank ansprechen. Implementiere Default-Deny.
Ich sehe das in fast jedem Audit. Teams verbringen Wochen damit, Firewalls außerhalb des Clusters zu konfigurieren, aber drinnen? Wilder Westen. Du musst laterale Bewegung einschränken. Wenn ein Frontend-Pod nicht mit dem Payment-Gateway reden muss, blockiere es.
Verwundbar: Nichts tun. Sich auf die Standardeinstellungen verlassen.
Gehärtet:
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
name: default-deny-all
namespace: default
spec:
podSelector: {}
policyTypes:
- Ingress
- EgressFüge explizite Allow-Regeln für das hinzu, was tatsächlich kommunizieren muss.
5. Zu großzügiges RBAC
Cluster-admin für alle? Tolle Idee, wenn du deinen Job hasst. Halte RBAC eng. Least Privilege ist nicht nur ein Buzzword, es ist das, was dich aus den Nachrichten heraushält.
Ehrlich, es ist ein Albtraum. Leute sind von RBAC genervt, weil es so geschwätzig ist. Also klatschen sie einfach eine Wildcard auf die Rolle und machen Feierabend. Aber * Verbs und * Resources heißen, dass jeder mit dieser Rolle alles darf. Secrets lesen, Deployments löschen oder privilegierte Pods hochfahren. Auditiere deine Rollen.
Verwundbar:
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: sloppy-dev
rules:
- apiGroups: ["*"]
resources: ["*"]
verbs: ["*"]Gehärtet:
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: restricted-dev
rules:
- apiGroups: [""]
resources: ["pods", "pods/log"]
verbs: ["get", "list", "watch"]6. Standard-Service-Accounts
Jeder Namespace bekommt einen default-Service-Account. Standardmäßig mountet K8s dessen Token in jeden Pod. Hat deine App eine SSRF- oder LFI-Lücke, bumm, schon haben sie das API-Token. Schalte das automatische Mounten ab.
Ein Angreifer schnappt sich dieses Token aus /var/run/secrets/kubernetes.io/serviceaccount/token und fängt an, deinen API-Server abzufragen. Selbst wenn der Default-Account keine Berechtigungen hat, ist das Information Disclosure. Und wenn jemand versehentlich eine Rolle an default gebunden hat? Dann bist du erledigt.
Gehärtet:
apiVersion: v1
kind: ServiceAccount
metadata:
name: default
automountServiceAccountToken: false7. Exponierte Dashboards
Wenn du 2026 das Kubernetes Dashboard immer noch ohne Authentifizierung ins Internet stellst, verdienst du, was kommt. Installier es einfach nicht. Nutze die CLI oder einen Managed Service.
Wir haben schon vor Jahren massive automatisierte Kampagnen gesehen, die exponierte Dashboards ausgenutzt haben, und irgendwie machen Leute das immer noch. Ein Dashboard mit gebundenem Service-Account ist buchstäblich eine Point-and-Click-Oberfläche für die Übernahme des Clusters. Weg mit dem Dashboard. Wenn deine Devs kubectl nicht bedienen können, sollten sie den Cluster nicht anfassen.
8. Fehlende Pod Security Standards
PSPs sind tot. Pod Security Admission ist angesagt. Erzwinge restriktive Policies auf Namespace-Ebene.
Wenn du keine Baseline- oder Restricted-Policies erzwingst, lassen Devs Pods einfach als root laufen. PSA ist eingebaut. Nutze es. Label deine Namespaces und lass den Admission Controller den schlechten Kram blockieren, bevor er überhaupt gescheduled wird.
Gehärtet:
apiVersion: v1
kind: Namespace
metadata:
name: prod
labels:
pod-security.kubernetes.io/enforce: restricted
pod-security.kubernetes.io/enforce-version: latest
pod-security.kubernetes.io/audit: restricted9. Ungescannte Images
latest von Docker Hub ziehen und nach Prod shippen. Was soll schon schiefgehen? Supply-Chain-Angriffe sind real. Scanne deine Images in der CI/CD und nutze Admission Controller, um kritische CVEs zu blockieren.
Ich hab es satt, das in PRs zu sehen. Du musst wissen, was in deinen Containern steckt. Eine verwundbare Version von Log4j oder OpenSSL, versteckt in irgendeinem Base Image aus einer beliebigen Registry, ist eine tickende Zeitbombe. Nutze Tools wie Trivy oder Grype. Noch besser: Nutze Distroless-Images. Hör auf, curl, wget und bash in Produktionsumgebungen auszuliefern. Angreifer lieben es, wenn du ihre Toolchain vorinstallierst.
10. Fehlende Resource Limits
Keine Limits heißt, ein einziger kompromittierter Pod kann den gesamten Node crashen, indem er den ganzen Speicher frisst. Ein trivialer DoS.
Cryptominer treiben deine CPU auf 100 %. Wenn du keine Limits hast, werden deine legitimen Apps gedrosselt und irgendwann per OOMKill beendet. Setz Requests und Limits für alles. Erzwinge sie mit LimitRanges.
Gehärtet:
apiVersion: v1
kind: Pod
metadata:
name: limited-pod
spec:
containers:
- name: app
image: nginx
resources:
requests:
cpu: "100m"
memory: "128Mi"
limits:
cpu: "500m"
memory: "512Mi"11. etcd ohne TLS
etcd ist das Gehirn deines Clusters. Wer es lesen kann, besitzt alles. Verschlüssele es bei der Übertragung und im Ruhezustand.
Wenn du deine eigene Control Plane betreibst und dein etcd unverschlüsselt ist, kann ein Angreifer, der auf einen Master-Node kommt, einfach die Datenbank dumpen. Das heißt Klartextzugriff auf jedes Secret im Cluster. Schalte EncryptionConfiguration ein.
12. Secrets im Klartext
Base64 ist keine Verschlüsselung. Hör auf, Secrets in Git zu committen. Nutze External Secrets Operator oder SOPS.
Ich kann nicht mehr zählen, wie oft ich AWS-Keys Base64-kodiert in einem Secret-Manifest gefunden habe, das in einem öffentlichen GitHub-Repo lag. Base64 kann ein 8-Jähriger dekodieren. Integriere deinen K8s-Cluster mit einem echten Vault, etwa HashiCorp Vault, AWS Secrets Manager oder Azure Key Vault.
13. Fehlendes Audit-Logging
Ohne Audit-Logs hast du keine Ahnung, wer was getan hat, wenn der Breach passiert. Aktiviere das Audit-Backend und schick die Logs an ein abgesichertes SIEM.
Schau, ich hab das hundertmal gesehen. Wenn das Incident-Response-Team anrückt, wollen sie als Erstes die Audit-Logs der Kube-API. Wenn du sie abgeschaltet hast, um Plattenplatz zu sparen, fliegst du blind. Du wirst nicht wissen, ob der Angreifer Secrets gedumpt, Rogue-Pods angelegt oder Backdoors eingebaut hat.
14. Ingress ohne TLS
Unverschlüsselter HTTP-Traffic im Jahr 2026? Cert-manager ist kostenlos. Let's Encrypt ist kostenlos. Hör auf, faul zu sein.
Es gibt null Ausreden dafür, TLS nicht an deinem Ingress zu terminieren. Wenn du interne Services per Klartext-HTTP ins Internet stellst, kann jeder, der an der Leitung sitzt, deine Session-Tokens und Credentials mitschneiden.
15. Umgehung der Sidecar-Injection
Wenn du ein Service Mesh nutzt, stell sicher, dass Angreifer die Sidecar-Proxys nicht über seltsame Annotations oder Host-Networking umgehen können. Erzwinge Sidecars über strikte Admission Webhooks.
Service Meshes wie Istio oder Linkerd sind super für mTLS und Zero Trust, aber wenn ein Entwickler (oder ein Angreifer) einfach die Annotation sidecar.istio.io/inject: "false" hinzufügen kann, umgeht er alle deine schicken Security-Policies komplett.
Schau, Kubernetes ist ein Biest. Aber wenn du diese 15 Dinge behebst, bist du 90 % der Branche voraus. Prüf jetzt deine Cluster. Hör auf zu raten und fang an, die Dinge abzuriegeln.
![Kubernetes-Sicherheit: 15 Fehlkonfigurationen, durch die dein Cluster übernommen wird [Daten 2026]](/_next/image?url=%2Fblog%2Ftest-mockup.jpg&w=3840&q=75&dpl=dpl_4APdW92RmtTARbNBj4X6xdJXX9hA)