Kubernetes

Kubernetes (oft als K8s abgekürzt) ist eine Open-Source-Plattform zur automatisierten Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen. Der Name stammt aus dem Griechischen und bedeutet "Steuermann" oder "Pilot". Kubernetes wurde ursprünglich von Google entwickelt und 2014 als Open-Source-Projekt veröffentlicht. Heute ist es der De-facto-Standard für Container-Orchestrierung in Produktionsumgebungen.

Geschichte und Entwicklung von Kubernetes

Die Geschichte von Kubernetes beginnt bei Google mit dem internen System Borg, das seit 2003 Tausende von Anwendungen auf Hunderttausenden von Servern orchestriert. Aus den Erfahrungen mit Borg und dem Nachfolger Omega entstand die Idee, diese Technologie der Öffentlichkeit zugänglich zu machen.

Wichtige Meilensteine

Die Entwicklung von Kubernetes war geprägt von schnellem Wachstum und breiter Unterstützung durch die Tech-Industrie:

• 2003-2004: Google entwickelt das interne Cluster-Management-System Borg
• Juni 2014: Joe Beda, Brendan Burns und Craig McLuckie kündigen Kubernetes als Open-Source-Projekt an
• Juli 2014: Microsoft, Red Hat, IBM und Docker treten der Kubernetes-Community bei
• Juli 2015: Kubernetes 1.0 wird veröffentlicht; Google gründet gemeinsam mit der Linux Foundation die Cloud Native Computing Foundation (CNCF)
• 2016-2017: Alle großen Cloud-Anbieter (AWS, Azure, Google Cloud) bieten managed Kubernetes-Services an
• 2018: Kubernetes wird das erste Projekt, das den "graduated"-Status der CNCF erreicht
• 2024: Kubernetes ist der Industriestandard für Container-Orchestrierung mit über 5,6 Millionen Entwicklern weltweit

Funktionsweise von Kubernetes

Kubernetes arbeitet mit einem deklarativen Konfigurationsmodell: Du beschreibst den gewünschten Zustand deiner Anwendung in YAML-Dateien, und Kubernetes sorgt automatisch dafür, dass dieser Zustand erreicht und aufrechterhalten wird. Das System überwacht kontinuierlich alle Komponenten und reagiert selbstständig auf Änderungen oder Ausfälle.

Cluster-Architektur

Ein Kubernetes-Cluster besteht aus zwei Hauptkomponenten: der Control Plane (Steuerungsebene) und den Worker Nodes (Arbeitsknoten). Die Control Plane trifft alle Entscheidungen über den Cluster, während die Worker Nodes die eigentlichen Anwendungen ausführen.

Zentrale Konzepte

Kubernetes führt mehrere Abstraktionsebenen ein, um containerisierte Anwendungen zu verwalten. Das Verständnis dieser Konzepte ist grundlegend für die Arbeit mit Kubernetes.

Pods

Ein Pod ist die kleinste deploybare Einheit in Kubernetes. Er enthält einen oder mehrere Container, die sich Netzwerk und Speicher teilen. Container innerhalb eines Pods kommunizieren über localhost und werden immer gemeinsam auf demselben Node ausgeführt.

# Beispiel: Einfacher Pod mit einem Nginx-Container
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: webserver
spec:
  containers:
  - name: nginx
    image: nginx:1.25
    ports:
    - containerPort: 80

Deployments

Ein Deployment definiert, wie eine Anwendung ausgeführt werden soll. Es verwaltet mehrere identische Pods (Replicas) und ermöglicht Rolling Updates sowie Rollbacks. In der Praxis arbeitest du fast immer mit Deployments statt mit einzelnen Pods.

# Beispiel: Deployment mit 3 Replicas
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: webserver
  template:
    metadata:
      labels:
        app: webserver
    spec:
      containers:
      - name: nginx
        image: nginx:1.25
        ports:
        - containerPort: 80

Services

Ein Service stellt eine stabile Netzwerkadresse für eine Gruppe von Pods bereit. Da Pods kurzlebig sind und ihre IP-Adressen sich ändern können, bieten Services eine konstante Möglichkeit, Anwendungen zu erreichen. Kubernetes unterstützt verschiedene Service-Typen:

• ClusterIP: Interner Service, nur innerhalb des Clusters erreichbar (Standard)
• NodePort: Macht den Service über einen Port auf jedem Node erreichbar
• LoadBalancer: Erstellt einen externen Load Balancer (bei Cloud-Anbietern)
• ExternalName: Mappt den Service auf einen externen DNS-Namen

ConfigMaps und Secrets

ConfigMaps speichern Konfigurationsdaten als Key-Value-Paare, die von Pods genutzt werden können. Secrets funktionieren ähnlich, sind aber für sensible Daten wie Passwörter, API-Keys oder Zertifikate gedacht. Secrets werden Base64-kodiert gespeichert und können zusätzlich verschlüsselt werden.

Hauptfunktionen von Kubernetes

Kubernetes bietet eine Vielzahl von Funktionen, die den Betrieb containerisierter Anwendungen in Produktionsumgebungen ermöglichen:

Automatische Skalierung

Kubernetes kann Anwendungen automatisch skalieren, um auf veränderte Last zu reagieren. Der Horizontal Pod Autoscaler (HPA) passt die Anzahl der Pod-Replicas basierend auf CPU-Auslastung, Speicherverbrauch oder benutzerdefinierten Metriken an. Der Vertical Pod Autoscaler (VPA) passt die Ressourcen (CPU/RAM) einzelner Pods an.

Self-Healing

Wenn ein Container abstürzt oder ein Node ausfällt, erkennt Kubernetes das automatisch und startet betroffene Container auf gesunden Nodes neu. Liveness Probes prüfen, ob ein Container noch läuft; Readiness Probes prüfen, ob er Traffic empfangen kann. Diese Mechanismen sorgen für hohe Verfügbarkeit ohne manuelle Eingriffe.

Rolling Updates und Rollbacks

Deployments ermöglichen Zero-Downtime-Updates: Kubernetes ersetzt Pods schrittweise durch neue Versionen, während der Service verfügbar bleibt. Wenn ein Update fehlschlägt, kannst du mit einem einzigen Befehl zur vorherigen Version zurückkehren.

# Update auf eine neue Version
kubectl set image deployment/nginx-deployment nginx=nginx:1.26

# Rollback zur vorherigen Version
kubectl rollout undo deployment/nginx-deployment

# Update-Status prüfen
kubectl rollout status deployment/nginx-deployment

Kubernetes vs. Docker Swarm

Beide Plattformen orchestrieren Container, unterscheiden sich aber in Komplexität und Funktionsumfang. Docker Swarm ist in Docker integriert und einfacher einzurichten, während Kubernetes mehr Funktionen und Flexibilität bietet.

Für kleine Teams und einfache Anwendungen kann Docker Swarm ausreichen. Für größere, komplexere Systeme mit Anforderungen an Skalierbarkeit und Hochverfügbarkeit ist Kubernetes die bessere Wahl.

Grundlegende kubectl-Befehle

kubectl ist das Kommandozeilen-Tool zur Interaktion mit Kubernetes-Clustern. Hier sind die wichtigsten Befehle für den Einstieg:

# Cluster-Informationen anzeigen
kubectl cluster-info

# Alle Pods im aktuellen Namespace anzeigen
kubectl get pods

# Deployments anzeigen
kubectl get deployments

# Services anzeigen
kubectl get services

# Deployment erstellen
kubectl apply -f deployment.yaml

# Pods skalieren
kubectl scale deployment nginx-deployment --replicas=5

# Logs eines Pods anzeigen
kubectl logs nginx-pod

# In einen Pod einloggen
kubectl exec -it nginx-pod -- /bin/bash

# Ressource löschen
kubectl delete deployment nginx-deployment

Managed Kubernetes-Services

Die großen Cloud-Anbieter bieten verwaltete Kubernetes-Dienste an, bei denen die Control Plane automatisch betrieben wird. Du zahlst nur für die Worker Nodes und kannst dich auf deine Anwendungen konzentrieren:

• Amazon EKS (Elastic Kubernetes Service): AWS-Integration mit IAM, VPC, ALB
• Google GKE (Google Kubernetes Engine): Tiefe Google-Cloud-Integration, Autopilot-Modus
• Azure AKS (Azure Kubernetes Service): Integration mit Azure Active Directory und Azure Services
• DigitalOcean Kubernetes: Einfacher, kostengünstiger Einstieg
• Hetzner Cloud: Deutsche Alternative mit gutem Preis-Leistungs-Verhältnis

Kubernetes-Ecosystem

Um Kubernetes herum hat sich ein reichhaltiges Ecosystem an Tools und Erweiterungen entwickelt, die den Betrieb vereinfachen:

• Helm: Paketmanager für Kubernetes; vereinfacht das Deployment komplexer Anwendungen
• Prometheus: Monitoring und Alerting für Kubernetes-Cluster
• Istio: Service Mesh für Traffic Management, Sicherheit und Observability
• ArgoCD: GitOps-Tool für kontinuierliche Deployments
• Lens: Desktop-Anwendung zur visuellen Verwaltung von Kubernetes-Clustern

Kubernetes in der IT-Praxis

Kubernetes ist aus modernen IT-Infrastrukturen nicht mehr wegzudenken. Unternehmen wie Spotify, Airbnb und die Deutsche Telekom setzen auf Kubernetes für ihre produktiven Workloads. Die Technologie ermöglicht es, Anwendungen schnell und zuverlässig bereitzustellen - unabhängig davon, ob sie in der eigenen Infrastruktur oder in der Cloud laufen.

Wer als Fachinformatiker für Systemintegration oder Fachinformatiker für Anwendungsentwicklung arbeitet, wird mit hoher Wahrscheinlichkeit auf Kubernetes treffen. Das gilt besonders in Unternehmen, die auf agile Entwicklung und DevOps-Praktiken setzen. Grundkenntnisse in Kubernetes - von der Cluster-Architektur bis zu kubectl-Befehlen - gehören heute zum erweiterten Standardwissen im IT-Bereich.

Quellen und weiterführende Links

• Offizielle Kubernetes-Dokumentation
• Kubernetes GitHub Repository
• Cloud Native Computing Foundation (CNCF)
• Kubernetes: The Documentary - Teil 1 (YouTube)
• kubectl Cheat Sheet
• Kubernetes History - IBM