Was ist Kubernetes und wofür wird es verwendet

Was Kubernetes macht

Einen einzelnen Docker-Container auf einer Maschine starten Sie von Hand. Fünfzig Container auf zehn Maschinen sind eine andere Sache: sie neu starten, wenn sie abstürzen, verschieben, wenn eine Maschine ausfällt, den Datenverkehr zwischen ihnen aufteilen, sie ohne Ausfallzeit aktualisieren. Kubernetes (kurz K8s) ist das System, das diese Verwaltung für Sie übernimmt.

Was ist Kubernetes?

Kubernetes ist eine Open-Source-Plattform für die Container-Orchestrierung. Sie wurde 2014 von Google entwickelt, basierend auf 15 Jahren Erfahrung in der Verwaltung von Containern im großen Maßstab, und wird jetzt von der Cloud Native Computing Foundation (CNCF) gepflegt.

Orchestrierung konkret: Ein Symphonieorchester braucht einen Dirigenten, damit Dutzende Musiker im Takt bleiben.

• Die Musiker sind Ihre Container, jeder weiß, wie er sein Instrument spielt
• Der Dirigent ist Kubernetes, der alle Musiker koordiniert
• Die Partitur ist die Konfiguration, die definiert, wie sie zusammenspielen sollen

Ohne einen Dirigenten würde jeder Musiker für sich allein spielen. Mit Kubernetes arbeiten alle Container harmonisch zusammen, um Ihre Anwendung zum Laufen zu bringen.

Der Name Kubernetes

Der Name stammt aus dem Griechischen κυβερνήτης (kybernetes) und bedeutet “Steuermann” oder “Pilot”. Das Logo mit dem siebenspeichigen Steuerrad repräsentiert dieses Konzept. Die Abkürzung K8s kommt daher, dass es 8 Buchstaben zwischen “K” und “s” gibt.

Warum brauchen Sie Kubernetes?

Docker löst das Problem der Erstellung und Ausführung einzelner Container. Aber in der Produktion werden die Dinge kompliziert:

• Was passiert, wenn ein Container um 3 Uhr morgens abstürzt?
• Wie verteilen Sie den Datenverkehr auf 10 Instanzen derselben Anwendung?
• Wie aktualisieren Sie die Anwendung ohne Ausfallzeit?
• Wie verwalten Sie 50 Microservices, die miteinander kommunizieren müssen?

Kubernetes beantwortet all diese Fragen.

Docker vs. Kubernetes: keine Alternativen

Ein häufiges Missverständnis ist zu denken, dass Kubernetes Docker ersetzt. In Wirklichkeit arbeiten sie zusammen:

Kubernetes kann Docker (oder andere Runtimes wie containerd) verwenden, um Container auszuführen. Sie müssen sich nicht zwischen ihnen entscheiden: Sie verwenden beide.

Wofür wird Kubernetes verwendet: 6 Probleme, die es löst

1. Self-Healing: Container, die sich selbst reparieren

Wenn ein Container abstürzt, erkennt Kubernetes dies und startet automatisch einen neuen. Niemand muss um 3 Uhr morgens wach sein, um Dienste manuell neu zu starten.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Kubernetes garantiert immer 3 aktive Replicas
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3  # Wenn einer stirbt, erstellt K8s einen neuen
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web
        image: nginx:latest

2. Automatische Skalierung

Sie haben einen Traffic-Spike? Kubernetes kann automatisch die Anzahl der Container erhöhen. Der Traffic nimmt ab? Es reduziert sie, um Ressourcen zu sparen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Skaliert automatisch zwischen 2 und 10 Replicas basierend auf CPU
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

3. Integrierter Load Balancer

Kubernetes verteilt den Datenverkehr automatisch auf alle verfügbaren Container. Wenn ein Container überlastet ist oder nicht reagiert, wird der Datenverkehr auf die anderen umgeleitet.

4. Rolling Updates: Aktualisierungen ohne Ausfallzeit

Wenn Sie eine neue Version deployen, geht Kubernetes so vor:

1. Startet neue Container mit der aktualisierten Version
2. Überprüft, ob sie korrekt funktionieren
3. Leitet den Datenverkehr schrittweise auf die neuen Container um
4. Beendet die alten Container

Wenn etwas schief geht, kann es automatisch ein Rollback auf die vorherige Version durchführen.

5. Service Discovery

In einem System mit vielen Microservices, wie findet Service A Service B? Kubernetes bietet ein internes DNS-System: Jeder Service hat einen Namen und Kubernetes übersetzt ihn in die richtige Adresse.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Der "database" Service wird unter "database.default.svc.cluster.local" erreichbar sein
apiVersion: v1
kind: Service
metadata:
  name: database
spec:
  selector:
    app: postgres
  ports:
  - port: 5432

6. Verwaltung von Secrets und Konfigurationen

Passwörter, API-Keys, Konfigurationen: Kubernetes verwaltet sie sicher und injiziert sie in Container, ohne sie im Code hartzukodieren.

1
2
3
4
5
6
7
8
9

# Secret für Datenbank-Anmeldedaten
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  username: YWRtaW4=      # base64-kodiert
  password: cGFzc3dvcmQ=  # base64-kodiert

Kubernetes-Konzepte: Pod, Node, Cluster, Deployment, Service

Pod

Der Pod ist die Grundeinheit von Kubernetes. Er enthält einen oder mehrere Container, die Netzwerk und Speicher teilen. In den meisten Fällen enthält ein Pod einen einzelnen Container.

Node

Ein Node ist eine Maschine (physisch oder virtuell), die Pods ausführt. Ein Kubernetes-Cluster hat typischerweise mehrere Nodes, um hohe Verfügbarkeit zu gewährleisten.

Cluster

Der Cluster ist die Gesamtheit aller von Kubernetes verwalteten Nodes. Er umfasst:

• Control Plane: das “Gehirn”, das Entscheidungen trifft (wo Pods platziert werden, wann sie skaliert werden, usw.)
• Worker Nodes: die Maschinen, die tatsächlich die Container ausführen

Deployment

Ein Deployment beschreibt den gewünschten Zustand Ihrer Anwendung: welches Image verwendet werden soll, wie viele Replicas, wie aktualisiert werden soll. Kubernetes stellt sicher, dass der tatsächliche Zustand immer dem gewünschten Zustand entspricht.

Service

Ein Service macht Pods im Netzwerk verfügbar. Er bietet eine stabile IP-Adresse und Load Balancing, auch wenn sich die zugrunde liegenden Pods ändern.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

┌─────────────────────────────────────────────────────────┐
│                      CLUSTER                            │
│  ┌─────────────────────────────────────────────────┐   │
│  │              CONTROL PLANE                       │   │
│  │  • API Server  • Scheduler  • Controller        │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
│  │   NODE 1    │  │   NODE 2    │  │   NODE 3    │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod A  │ │  │ │  Pod A  │ │  │ │  Pod B  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod B  │ │  │ │  Pod C  │ │  │ │  Pod C  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  └─────────────┘  └─────────────┘  └─────────────┘    │
└─────────────────────────────────────────────────────────┘

Kubernetes vs. Docker Swarm

Docker hat seinen eigenen integrierten Orchestrator: Docker Swarm. Der Unterschied:

Wann Docker Swarm wählen:

• Kleine/mittlere Projekte
• Teams mit wenig Orchestrierungserfahrung
• Notwendigkeit, schnell zu starten

Wann Kubernetes wählen:

• Enterprise- oder wachsende Projekte
• Bedarf an erweiterten Funktionen
• Team bereit, in Lernen zu investieren
• Wichtige Skalierungsanforderungen

Wann Sie Kubernetes nicht verwenden sollten

Kubernetes ist nicht immer die richtige Antwort. Vermeiden Sie es, wenn:

• Sie wenige Container haben: 2-3 Container mit K8s zu verwalten ist wie einen LKW zu benutzen, um Einkäufe zu transportieren
• Das Team klein ist: die operative Komplexität kann die Vorteile überwiegen
• Die Anwendung monolithisch ist: K8s glänzt bei Microservices
• Sie keine Skalierungsanforderungen haben: wenn der Traffic konstant und vorhersehbar ist, brauchen Sie es möglicherweise nicht
• Begrenztes Budget: Kubernetes-Cluster haben erhebliche Betriebskosten

Einfachere Alternativen

Auf einem einzelnen Host deckt Docker Compose das meiste ab, wofür Leute zuerst zu Kubernetes greifen.

Wie Sie mit Kubernetes anfangen

Wenn Sie Kubernetes erkunden möchten, ohne den Verstand zu verlieren, hier ist ein schrittweiser Weg:

1. Lernen Sie die Docker-Grundlagen

Wenn Sie es noch nicht getan haben, beginnen Sie mit Docker. Kubernetes orchestriert Container, also müssen Sie zuerst wissen, wie man sie erstellt.

2. Experimentieren Sie lokal mit Minikube

Minikube erstellt einen Kubernetes-Cluster auf Ihrem Computer. Perfekt zum Lernen ohne Cloud-Kosten.

1
2
3
4
5

# Installieren Sie Minikube und starten Sie einen lokalen Cluster
minikube start

# Überprüfen Sie, ob es funktioniert
kubectl get nodes

3. Erkunden Sie kubectl

kubectl ist der Befehl zur Interaktion mit Kubernetes. Lernen Sie die grundlegenden Operationen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Laufende Pods anzeigen
kubectl get pods

# Ressourcen aus einer YAML-Datei erstellen
kubectl apply -f deployment.yaml

# Pod-Logs anzeigen
kubectl logs pod-name

# In einen Container einsteigen
kubectl exec -it pod-name -- /bin/bash

4. Probieren Sie einen Managed Cluster

Wenn Sie bereit für die Produktion sind, nutzen Sie einen verwalteten Dienst:

• Google Kubernetes Engine (GKE)
• Amazon Elastic Kubernetes Service (EKS)
• Azure Kubernetes Service (AKS)

Diese Dienste verwalten die Control Plane für Sie und reduzieren die operative Komplexität.

Brauchen Sie Kubernetes wirklich?

Kubernetes rechtfertigt seine Komplexität, wenn Sie viele Dienste betreiben, über mehr als eine Maschine verteilt, und die Verfügbarkeit zählt. Self-Healing, Autoscaling und Rolling Updates baut man nur schwer selbst nach, und Kubernetes liefert sie fertig.

Unterhalb dieser Schwelle kostet es mehr, als es einbringt. Eine Handvoll Container auf einem Server laufen problemlos mit Docker Compose. Ein kleiner Cluster mit überschaubaren Anforderungen läuft problemlos mit Docker Swarm. Greifen Sie zu Kubernetes, wenn diese nicht mehr mithalten, nicht vorher.

Um es zu lernen, ohne einen Produktions-Cluster zu bezahlen, beginnen Sie mit Minikube auf Ihrem eigenen Rechner und arbeiten Sie die Konzepte oben einzeln durch.

Verwandte Artikel

• Was ist Docker und wofür wird es verwendet
• Was ist ein Docker-Volume
• Docker vs Podman: Unterschiede und welches wählen