Kubernetes

Kubernetes (oft als K8s abgekuerzt) 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 urspruenglich von Google entwickelt und 2014 als Open-Source-Projekt veroeffentlicht. Heute ist es der De-facto-Standard fuer 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 Oeffentlichkeit zugaenglich zu machen.

Wichtige Meilensteine

Die Entwicklung von Kubernetes war gepraegt von schnellem Wachstum und breiter Unterstuetzung durch die Tech-Industrie:

• 2003-2004: Google entwickelt das interne Cluster-Management-System Borg
• Juni 2014: Joe Beda, Brendan Burns und Craig McLuckie kuendigen 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 veroeffentlicht; Google gruendet gemeinsam mit der Linux Foundation die Cloud Native Computing Foundation (CNCF)
• 2016-2017: Alle grossen 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 fuer Container-Orchestrierung mit ueber 5,6 Millionen Entwicklern weltweit

Funktionsweise von Kubernetes

Kubernetes arbeitet mit einem deklarativen Konfigurationsmodell: Du beschreibst den gewuenschten Zustand deiner Anwendung in YAML-Dateien, und Kubernetes sorgt automatisch dafuer, dass dieser Zustand erreicht und aufrechterhalten wird. Das System ueberwacht kontinuierlich alle Komponenten und reagiert selbststaendig auf Aenderungen oder Ausfaelle.

Cluster-Architektur

Ein Kubernetes-Cluster besteht aus zwei Hauptkomponenten: der Control Plane (Steuerungsebene) und den Worker Nodes (Arbeitsknoten). Die Control Plane trifft alle Entscheidungen ueber den Cluster, waehrend die Worker Nodes die eigentlichen Anwendungen ausfuehren.

Zentrale Konzepte

Kubernetes fuehrt mehrere Abstraktionsebenen ein, um containerisierte Anwendungen zu verwalten. Das Verstaendnis dieser Konzepte ist grundlegend fuer die Arbeit mit Kubernetes.

Pods

Ein Pod ist die kleinste deploybare Einheit in Kubernetes. Er enthaelt einen oder mehrere Container, die sich Netzwerk und Speicher teilen. Container innerhalb eines Pods kommunizieren ueber localhost und werden immer gemeinsam auf demselben Node ausgefuehrt.

# 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 ausgefuehrt werden soll. Es verwaltet mehrere identische Pods (Replicas) und ermoeglicht 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 fuer eine Gruppe von Pods bereit. Da Pods kurzlebig sind und ihre IP-Adressen sich aendern koennen, bieten Services eine konstante Moeglichkeit, Anwendungen zu erreichen. Kubernetes unterstuetzt verschiedene Service-Typen:

• ClusterIP: Interner Service, nur innerhalb des Clusters erreichbar (Standard)
• NodePort: Macht den Service ueber 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 koennen. Secrets funktionieren aehnlich, sind aber fuer sensible Daten wie Passwoerter, API-Keys oder Zertifikate gedacht. Secrets werden Base64-kodiert gespeichert und koennen zusaetzlich verschluesselt werden.

Hauptfunktionen von Kubernetes

Kubernetes bietet eine Vielzahl von Funktionen, die den Betrieb containerisierter Anwendungen in Produktionsumgebungen ermoeglichen:

Automatische Skalierung

Kubernetes kann Anwendungen automatisch skalieren, um auf veraenderte 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 abstuerzt oder ein Node ausfaellt, erkennt Kubernetes das automatisch und startet betroffene Container auf gesunden Nodes neu. Liveness Probes pruefen, ob ein Container noch laeuft; Readiness Probes pruefen, ob er Traffic empfangen kann. Diese Mechanismen sorgen fuer hohe Verfuegbarkeit ohne manuelle Eingriffe.

Rolling Updates und Rollbacks

Deployments ermoeglichen Zero-Downtime-Updates: Kubernetes ersetzt Pods schrittweise durch neue Versionen, waehrend der Service verfuegbar bleibt. Wenn ein Update fehlschlaegt, kannst du mit einem einzigen Befehl zur vorherigen Version zurueckkehren.

# 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 pruefen
kubectl rollout status deployment/nginx-deployment

Kubernetes vs. Docker Swarm

Beide Plattformen orchestrieren Container, unterscheiden sich aber in Komplexitaet und Funktionsumfang. Docker Swarm ist in Docker integriert und einfacher einzurichten, waehrend Kubernetes mehr Funktionen und Flexibilitaet bietet.

Fuer kleine Teams und einfache Anwendungen kann Docker Swarm ausreichen. Fuer groessere, komplexere Systeme mit Anforderungen an Skalierbarkeit und Hochverfuegbarkeit ist Kubernetes die bessere Wahl.

Grundlegende kubectl-Befehle

kubectl ist das Kommandozeilen-Tool zur Interaktion mit Kubernetes-Clustern. Hier sind die wichtigsten Befehle fuer 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 loeschen
kubectl delete deployment nginx-deployment

Managed Kubernetes-Services

Die grossen Cloud-Anbieter bieten verwaltete Kubernetes-Dienste an, bei denen die Control Plane automatisch betrieben wird. Du zahlst nur fuer 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, kostenguenstiger Einstieg
• Hetzner Cloud: Deutsche Alternative mit gutem Preis-Leistungs-Verhaeltnis

Kubernetes-Ecosystem

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

• Helm: Paketmanager fuer Kubernetes; vereinfacht das Deployment komplexer Anwendungen
• Prometheus: Monitoring und Alerting fuer Kubernetes-Cluster
• Istio: Service Mesh fuer Traffic Management, Sicherheit und Observability
• ArgoCD: GitOps-Tool fuer 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 fuer ihre produktiven Workloads. Die Technologie ermoeglicht es, Anwendungen schnell und zuverlaessig bereitzustellen - unabhaengig davon, ob sie in der eigenen Infrastruktur oder in der Cloud laufen.

Wer als Fachinformatiker fuer Systemintegration oder Fachinformatiker fuer 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 - gehoeren heute zum erweiterten Standardwissen im IT-Bereich.

Quellen und weiterfuehrende Links

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