Was ist Kubernetes und Wofür Wird Es Verwendet: Vollständiger Leitfaden für Anfänger

Einführung

Sie haben gelernt, Docker und Container zu verwenden, aber jetzt fragen Sie sich: “Wie verwalte ich Dutzende oder Hunderte von Containern in der Produktion?”. Die Antwort ist Kubernetes, oft als K8s abgekürzt. In diesem Leitfaden erkläre ich Ihnen, was es ist, wie es funktioniert und wann es sinnvoll ist, es zu verwenden.

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.

Aber was bedeutet “Orchestrierung”? Stellen Sie sich ein Symphonieorchester vor:

• 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: Sie Sind 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, macht Kubernetes:

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

Grundlegende Kubernetes-Konzepte

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. Was ist 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 Man Kubernetes NICHT Verwenden Sollte

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

Wie Man mit Kubernetes Anfängt

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.

Fazit

Kubernetes ist ein leistungsstarkes Werkzeug, das echte Probleme bei der Verwaltung von containerisierten Anwendungen im großen Maßstab löst. Es bietet Self-Healing, automatische Skalierung, Deployments ohne Ausfallzeit und vieles mehr.

Allerdings bringt es erhebliche Komplexität mit sich. Bevor Sie es einführen, fragen Sie sich:

• Muss ich wirklich viele Container orchestrieren?
• Hat mein Team die Fähigkeiten (oder die Zeit, sie zu erwerben)?
• Rechtfertigen die Vorteile die zusätzliche Komplexität?

Wenn die Antwort ja ist, kann Kubernetes die Art und Weise transformieren, wie Sie Ihre Anwendungen verwalten. Wenn nicht, könnten einfachere Lösungen wie Docker Compose oder Docker Swarm die bessere Wahl sein.

Der Rat ist, klein anzufangen: Experimentieren Sie mit Minikube, üben Sie die grundlegenden Konzepte und skalieren Sie schrittweise zu komplexeren Clustern, wenn Sie sie wirklich brauchen.