Kubernetes verstehen

Was ist Kubernetes?

Kubernetes (kurz: K8s) ist ein Open-Source-System zur Verwaltung von Container-Anwendungen. Es wurde ursprünglich von Google entwickelt und ist heute der de-facto-Standard für Container-Orchestrierung.

Einfacher gesagt: Kubernetes kümmert sich darum, dass deine Container-Anwendungen zuverlässig laufen – auch wenn Server ausfallen, Last steigt oder Software aktualisiert werden muss.

Warum braucht man Kubernetes?

Mit Docker läuft ein einzelner Container problemlos. Aber in der Praxis hat man schnell viele Container:

• Eine Web-App, eine Datenbank, ein Cache, eine Queue, ein Auth-Service...
• Mehrere Instanzen für Hochverfügbarkeit
• Unterschiedliche Umgebungen: Dev, Staging, Prod

Das alles manuell zu verwalten ist fehleranfällig und nicht skalierbar. Kubernetes automatisiert diese Aufgaben.

Die wichtigsten Kubernetes-Konzepte

Pod – die kleinste Einheit

Ein Pod ist die kleinste Einheit in Kubernetes. Er enthält einen oder mehrere Container, die zusammen laufen, sich eine IP-Adresse teilen und denselben Storage nutzen können.

In der Praxis hat ein Pod meist genau einen Container. Ausnahme: ein Hauptcontainer plus ein "Sidecar"-Container (z.B. für Logging oder Security).

Deployment – wie du Pods definierst und skalierst

Ein Deployment beschreibt, wie viele Instanzen eines Pods laufen sollen und welches Container-Image genutzt wird. Kubernetes sorgt dafür, dass immer genau diese Anzahl läuft – auch wenn einzelne Pods abstürzen.

apiVersion: apps/v1
kind: Deployment
metadata:
name: webapp
spec:
replicas: 3        # 3 Instanzen laufen immer
selector:
  matchLabels:
    app: webapp
template:
  spec:
    containers:
    - name: webapp
      image: webapp:1.2.0
      ports:
      - containerPort: 8080

Service – wie Container nach außen erreichbar sind

Pods haben wechselnde IP-Adressen. Ein Service gibt einer Gruppe von Pods eine stabile Adresse. Er verteilt Traffic automatisch auf alle gesunden Pods.

• ClusterIP – nur intern im Cluster erreichbar
• NodePort – über eine Port-Nummer von außen erreichbar
• LoadBalancer – bekommt eine externe IP (z.B. in AWS oder GCP)

Namespace – logische Trennung

Namespaces trennen Ressourcen im selben Cluster – z.B. nach Team, Umgebung oder Anwendung. Einfaches Multi-Tenancy-Modell ohne mehrere Cluster betreiben zu müssen.

ConfigMap und Secret

Konfigurationsdaten und sensible Daten (Passwörter, API-Keys) werden nicht ins Image eingebaut, sondern als ConfigMap oder Secret getrennt verwaltet. Das ermöglicht sichere, wiederverwendbare Images.

Kubernetes-Architektur kurz erklärt

Ein Kubernetes-Cluster besteht aus zwei Typen von Knoten:

Kubernetes und Sicherheit

Kubernetes hat viele Security-Features, die richtig konfiguriert werden müssen:

• RBAC (Role-Based Access Control) – wer darf was im Cluster
• Network Policies – welche Pods dürfen miteinander reden
• Pod Security Standards – verhindert privilegierte Container
• Secrets Management – Secrets sollten nicht in etcd im Klartext liegen (Integration mit Vault, AWS Secrets Manager)
• Image Scanning – nur geprüfte Images deployen (z.B. mit Cosign, Kyverno)

Im DevSecOps-Kontext werden diese Security-Konfigurationen als Code verwaltet – überprüft und enforced per CI/CD-Pipeline.

Kubernetes in der Praxis: Wo läuft es?

Kubernetes läuft on-premise oder in der Cloud. Managed Kubernetes-Dienste nehmen den Betrieb des Control Planes ab:

• AWS EKS – Amazon Elastic Kubernetes Service
• Google GKE – Google Kubernetes Engine (das Original)
• Azure AKS – Azure Kubernetes Service
• OpenShift – Red Hat's Enterprise-Kubernetes-Distribution

Lohnt sich Kubernetes für mein Team?

Kubernetes bringt echten Nutzen, wenn:

• Mehrere Microservices oder viele Container betrieben werden
• Hochverfügbarkeit und Skalierung wichtig sind
• Teams unabhängig voneinander deployen wollen
• Compliance und Auditierbarkeit des Betriebs gefordert sind

Für einfache Monolithen oder sehr kleine Teams kann Kubernetes überdimensioniert sein. Hier lohnt erst der Einstieg in CI/CD und Docker, bevor man auf K8s wechselt.

Nächste Schritte: Kubernetes lernen

1. Docker verstehen – Kubernetes baut auf Container-Grundlagen auf
2. kubectl üben – das Kommandozeilen-Tool für K8s (kubectl get pods, kubectl apply -f)
3. Minikube oder k3s lokal starten – eigener Mini-Cluster auf dem Laptop
4. Erste Deployment + Service erstellen – die YAML-Konfiguration hands-on schreiben
5. GitOps einführen – Kubernetes-Konfiguration in Git versionieren und via ArgoCD deployen