Kubernetes für Einsteiger: Komplette Anleitung zur Container-Orchestrierung

Kubernetes hat die Art, wie Unternehmen Software deployen, fundamental verändert. Laut einer Studie von CNCF nutzen mittlerweile über 70 % der Fortune-500-Unternehmen Kubernetes für ihre Produktionsworkloads. Wenn Sie noch nicht auf diesen Zug aufgesprungen sind, riskieren Sie, den Anschluss an agiler arbeitende Wettbewerber zu verlieren. In diesem Kubernetes Tutorial für Einsteiger zeige ich Ihnen, wie Sie Container Orchestrierung erfolgreich in Ihrer Infrastruktur implementieren.

Was ist Kubernetes und warum brauchen Sie es?

Stellen Sie sich folgendes Szenario vor: Ihre E-Commerce-Plattform läuft auf drei virtuellen Maschinen. Black Friday kommt, der Traffic steigt um 500 %. Ohne Kubernetes müssen Sie manuell neue Instanzen hochfahren, Load Balancer neu konfigurieren und manuell deployen. Mit Kubernetes passiert das automatisch.

Kubernetes, ursprünglich bei Google entwickelt und 2015 an die CNCF übergeben, automatisiert die Verwaltung von Linux-Containern auf distributed Systems. Die aktuelle stabile Version ist 1.28 (Codename: Gardener), mit Support bis September 2024.

Die Vorteile für Unternehmen im Überblick:

• Automatische Skalierung: Horizontales Pod Autoscaling (HPA) reagiert auf CPU-Auslastung oder benutzerdefinierte Metriken
• Selbstheilung: Kubernetes startet fehlgeschlagene Container automatisch neu und ersetzt nicht-responsive Pods
• Rolling Updates: Zero-Downtime-Deployments ohne manuelle Eingriffe
• Ressourceffizienz: Bis zu 40 % bessere Auslastung der Infrastruktur im Vergleich zu traditionellen VM-Deployments

Container Orchestrierung: Die Grundlagen

Bevor wir tiefer einsteigen, klären wir den Begriff Container Orchestrierung. Stellen Sie sich ein Orchester vor: Verschiedene Musiker (Container) spielen unterschiedliche Instrumente, aber jemand muss koordinieren, wann wer spielt, wie laut, und wie das Gesamtwerk klingt. Genau das tut Kubernetes für Ihre Container.

Warum nicht einfach Docker verwenden?

Docker ist fantastisch für lokale Entwicklung und Single-Server-Deployments. Aber wenn Sie mehrere Server haben, wird es schnell komplex:

• Wie verteilen Sie Container auf verschiedene Hosts?
• Wie handhaben Sie Netzwerk-Kommunikation zwischen Containern?
• Was passiert, wenn ein Server ausfällt?
• Wie skalieren Sie horizontal?

Docker Compose managed nur einen einzelnen Host. Kubernetes hingegen orchestriert ganze Cluster mit Hunderten von Nodes nahtlos.

Die Kubernetes-Architektur verstehen

Ein Kubernetes-Cluster besteht aus zwei Hauptkomponenten: dem Control Plane (ehemals Master) und den Worker Nodes.

Control Plane: Das Gehirn des Clusters

Die Control Plane koordiniert alle Aktivitäten im Cluster. Sie enthält:

kube-apiserver: Die zentrale REST-Schnittstelle für alle Cluster-Operationen. Bei AWS EKS kostet die Control Plane etwa 0,10 USD pro Stunde (73 USD/Monat), unabhängig von der Cluster-Größe.

etcd: Ein verteilter Key-Value-Store, der den gesamten Cluster-Zustand speichert. Für Produktionsumgebungen empfehle ich mindestens drei etcd-Instanzen für High Availability.

kube-scheduler: Weist neu erstellte Pods Nodes zu, basierend auf Ressourcenverfügbarkeit und Affinity-Regeln.

kube-controller-manager: Führt verschiedene Controller-Prozesse aus (Node Controller, Replication Controller, Endpoints Controller).

Worker Nodes: Die Arbeitstiere

Jeder Worker Node beherbergt die Container Ihrer Anwendungen und besteht aus:

Kubelet: Ein Agent, der mit der Control Plane kommuniziert und Container verwaltet.

Kube-Proxy: Netzwerk-Proxy, der TCP/UDP-Routing für Pod-Kommunikation übernimmt.

Container Runtime: Docker, containerd oder CRI-O — die Engine, die tatsächlich Container startet.

Pods: Kleinste deploybare Einheiten

Ein Pod ist die kleinste Einheit in Kubernetes und repräsentiert einen oder mehrere Container, die gemeinsam laufen und geteilte Ressourcen haben. Ein Pod bekommt eine eigene IP-Adresse, aber Container innerhalb teilen den Network Namespace.

Best Practice: Ein Pod pro Container ist der Standard. Multicontainer-Pods (Sidecar-Pattern) nur für eng gekoppelte Logik wie Logging-Agenten.

Schritt-für-Schritt: Erster Kubernetes-Cluster

1. Cluster erstellen: Managed vs. Self-Managed

Für die meisten Unternehmen empfehle ich Managed Kubernetes Services:

AWS EKS: Ab 0,10 USD/Stunde + EC2-Kosten. Beste Integration mit AWS-Services wie IAM, VPC, CloudWatch.

Azure AKS: Kostenlos für den Control Plane. Sie zahlen nur für VMs, Storage, Netzwerk.

Google GKE: Autopilot-Modus ab 0,10 USD/Stunde pro Zone. Excellent für hybrid Cloud-Szenarien.

Oracle Cloud Container Engine for Kubernetes (OKE): Besonders attraktiv für Oracle-Kunden — kostenloser Control Plane, Sie zahlen nur Compute.

Self-Managed Clusters (kubeadm, k3s) sind nur sinnvoll, wenn Sie spezifische Control-Plane-Konfigurationen benötigen oder in sehr restriktiven Umgebungen arbeiten.

2. kubectl installieren und konfigurieren

# macOS
brew install kubectl

# Linux
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

# Verification
kubectl version --client

Konfiguration erfolgt über kubeconfig (standardmäßig ~/.kube/config). Bei EKS nutzen Sie:

aws eks update-kubeconfig --region eu-central-1 --name mein-cluster

3. Erste Deployment erstellen

Erstellen Sie eine Datei namens deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: nginx
        image: nginx:1.25
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "128Mi"
            cpu: "250m"
          limits:
            memory: "256Mi"
            cpu: "500m"

Anwenden mit:

kubectl apply -f deployment.yaml
kubectl get deployments
kubectl get pods

4. Service erstellen für Netzwerk-Zugriff

Pods sind flüchtig — wenn sie sterben, bekommen sie neue IPs. Services abstrahieren diesen Detail:

apiVersion: v1
kind: Service
metadata:
  name: web-app-service
spec:
  selector:
    app: web-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Bei AWS erstellt dies automatisch einen ELB. Provisioning dauert typischerweise 30-90 Sekunden.

Kubernetes Tutorial für Fortgeschrittene: Production-Best-Practices

Resource Limits und QoS

Ohne Resource Requests und Limits riskieren Sie zwei Extreme: Container, die nie scheduled werden, weil Requests zu hoch sind, oder Nodes, die überlastet werden, weil Limits fehlen.

QoS-Klassen in Kubernetes:

• Guaranteed: Requests = Limits für alle Container (höchste Priorität)
• Burstable: Requests definiert, aber Limits unterschiedlich oder nicht gesetzt
• BestEffort: Weder Requests noch Limits definiert (niedrigste Priorität)

Health Checks konfigurieren

Kubernetes unterscheidet zwischen:

Liveness Probe: Ist der Container noch lebendig? Wenn fehlgeschlagen, wird er neugestartet.

Readiness Probe: Ist der Container bereit, Traffic zu empfangen? Wenn fehlgeschlagen, wird er aus dem Service herausgenommen.

Startup Probe: Für langsam startende Anwendungen (z.B. JVM-basierte Apps). Deaktiviert Liveness/Readiness während der Startup-Phase.

Namespaces für Umgebungs-Trennung

Nutzen Sie Namespaces für logische Trennung:

kubectl create namespace entwicklung
kubectl create namespace staging
kubectl create namespace produktion

Implementieren Sie ResourceQuotas pro Namespace:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: produktion-quota
  namespace: produktion
spec:
  hard:
    pods: "50"
    requests.cpu: "8"
    requests.memory: 16Gi
    limits.cpu: "16"
    limits.memory: 32Gi

Monitoring und Logging

Observability Stack aufsetzen

Für Production-Umgebungen empfehle ich den CNCF-Stack:

Prometheus + Grafana: Metrics-Sammlung und Visualisierung. Prometheus kostet nur die Infrastruktur — etwa 2-4 USD/Monat für einen kleinen Cluster.

Loki: Log-Aggregation von allen Pods. 10x günstiger als Elasticsearch für Logs.

Jaeger oder Tempo: Distributed Tracing für Performance-Analyse.

Kubernetes Dashboard vs. Moderne Alternativen

Das offizielle Kubernetes Dashboard ist nützlich für den Start, aber für Production empfehle ich:

Lens: Desktop-App mit hervorragender UX. Kostenlos für persönliche Nutzung, Teams ab 9 USD/Monat.

Octant: Open-Source, von VMware entwickelt. Gut für lokale Entwicklung.

Weave GitOps oder Argo CD: Für GitOps-Workflows — Continuous Deployment aus Git heraus.

Sicherheit in Kubernetes

RBAC (Role-Based Access Control)

Das Principle of Least Privilege ist nicht verhandelbar. Erstellen Sie spezifische Roles und RoleBindings:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: entwicklung
  name: developer
rules:
- apiGroups: [""]
  resources: ["pods", "services", "configmaps"]
  verbs: ["get", "list", "watch", "create", "update"]
- apiGroups: ["apps"]
  resources: ["deployments"]
  verbs: ["get", "list", "update"]

Pod Security Standards

Nutzen Sie Pod Security Standards (PSS) statt der veralteten PSPs (Pod Security Policies):

apiVersion: v1
kind: Namespace
metadata:
  name: gesicherte-umgebung
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/audit: restricted
    pod-security.kubernetes.io/warn: restricted

Secrets vs. ConfigMaps

Secrets sind Base64-encoded, nicht verschlüsselt! Für Production:

• AWS Secrets Manager Integration über CSI-Driver
• HashiCorp Vault für zentrale Secret-Verwaltung
• Sealed Secrets von Bitnami für GitOps-Workflows

Herausforderungen und wie Sie sie meistern

Komplexität der Anfang

Kubernetes hat eine steile Lernkurve. Rechnen Sie mit 2-3 Monaten für ein solides Verständnis. Investieren Sie in offizielle Kurse: CKA (Certified Kubernetes Administrator) kostet 395 USD und validiert fundamentales Wissen.

Networking kann verwirrend sein

Kubernetes Networking Model basiert auf der Annahme, dass Pods über eine einzige IP direkt erreichbar sind. Dienste wie Cilium, Calico oder Weave abstrahieren die Komplexität. Für die meisten AWS-Deployments empfehle ich Cilium mit eBPF für bessere Performance.

Stateful Applications erfordern besondere Aufmerksamkeit

Datenbanken und stateful Workloads sind nicht trivial in Kubernetes. Nutzen Sie:

• PersistentVolumeClaims (PVCs) für Storage
• StatefulSets statt Deployments für deterministische Namensgebung und stabile Netzwerk-Identitäten
• Operators wie Prometheus Operator oder cert-manager für komplexe Anwendungen

Kostenmanagement

Kubernetes selbst ist kostenlos (open source), aber die zugrundeliegende Infrastruktur nicht. FinOps-Praktiken sind essenziell:

• Rightsizing von Pods mit Vertical Pod Autoscaler (VPA)
• Node Autoscaler für automatische Skalierung
• Spot/Preemptible Instances für nicht-kritische Workloads (bis zu 90 % Ersparnis)
• Cluster Autoscaler konfiguriert für Right-Sizing

Integration mit Docker Kubernetes

Docker Desktop enthält seit Version 2.1 einen integrierten Kubernetes-Cluster. Für lokale Entwicklung ideal:

# Kubernetes in Docker Desktop aktivieren
# Settings > Kubernetes > Enable Kubernetes

# Wechseln zwischen Kontexten
kubectl config get-contexts
kubectl config use-context docker-desktop

Der Vorteil: Sie können Docker Compose direkt nach Kubernetes deployen mit Tools wie Kompose:

brew install kompose
kompose convert

Das konvertiert docker-compose.yaml automatisch zu Kubernetes-Ressourcen. Für Produktions-Deployments empfehle ich allerdings, von Anfang an native Kubernetes-Manifests zu schreiben.

Fazit und nächste Schritte

Kubernetes ist nicht nur ein Technologie-Hype — es ist die De-facto-Standard für Container-Orchestrierung in Production-Umgebungen. Die Investition in das Verständnis dieser Plattform zahlt sich langfristig aus.

Ihre nächsten Schritte:

1. Starten Sie mit einem Managed Cluster (EKS, AKS, GKE oder OKE) für Produktion
2. Deployen Sie eine einfache Stateless-App, um die Grundlagen zu verinnerlichen
3. Fügen Sie Health Checks, Resource Limits und RBAC hinzu
4. Implementieren Sie CI/CD mit Argo CD oder Flux
5. Setzen Sie Monitoring mit Prometheus und Grafana auf

Ciro Cloud unterstützt Sie bei der Migration Ihrer Infrastruktur zu Kubernetes — von der Architektur-Beratung bis zum Production-Deployment. Kontaktieren Sie uns für ein unverbindliches Erstgespräch.

Relevante Ressourcen für Kubernetes Einsteiger:

• Offizielle Kubernetes-Dokumentation (kubernetes.io/docs)
• CNCF Online Training (cncf.io)
• KillerCoda für interaktive Labs
• CNCF End User Technology Radar für Best Practices