Kubernetes für Einsteiger

Kubernetes für Einsteiger: Dein Weg zur Container-Orchestrierung – Eine Dummies-Anleitung

Herzlich willkommen, liebe Technologie-Enthusiasten und alle, die schon einmal vom Buzzword "Kubernetes" gehört, aber noch nicht ganz verstanden haben, was sich dahinter verbirgt! Keine Sorge, ihr seid hier genau richtig. In diesem Blogpost nehmen wir euch an die Hand und erklären, was Kubernetes ist, was es kann, wie man die ersten Schritte macht und warum es aus der modernen Software-Entwicklung nicht mehr wegzudenken ist.

Bereit? Dann tauchen wir ein!

1. Was ist Kubernetes überhaupt? Eine einfache Erklärung

Stell dir vor, du hast eine App entwickelt. Sagen wir, eine einfache Webanwendung. Diese App läuft nicht einfach "so", sondern benötigt eine Umgebung – einen Server, Betriebssystem, Datenbanken, etc. Um deine App und ihre Abhängigkeiten sauber zu verpacken, nutzt du Container (z.B. mit Docker). Container sind wie kleine, abgeschlossene Pakete, die alles enthalten, was deine App zum Laufen braucht. Das ist super, denn so läuft deine App überall gleich.

Aber was passiert, wenn:

Deine App plötzlich Tausende von Nutzern gleichzeitig hat und du mehr Ressourcen brauchst?
Ein Server ausfällt und deine App nicht mehr erreichbar ist?
Du eine neue Version deiner App ausrollen möchtest, ohne Downtime?
Du hunderte von Containern verwalten musst?

Hier kommt Kubernetes ins Spiel! Manchmal auch als K8s bezeichnet (K, 8 Buchstaben, s), ist Kubernetes ein Open-Source-System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen.

Eine Analogie: Stell dir Kubernetes als den Dirigenten eines Orchesters vor, das aus vielen Musikern (Containern) besteht. Der Dirigent sorgt dafür, dass alle Musiker im richtigen Takt spielen, die richtige Lautstärke haben, neue Musiker hinzugefügt werden, wenn ein Stück komplexer wird, und dass das Konzert weitergeht, selbst wenn ein Musiker kurz ausfällt. Kubernetes ist also das Betriebssystem für deine Container.

2. Was kann Kubernetes? Die Superkräfte von K8s

Kubernetes ist kein "nice-to-have", sondern ein Game-Changer. Hier sind seine wichtigsten Fähigkeiten:

Automatisches Skalieren: Wenn deine App plötzlich mehr Traffic bekommt, startet Kubernetes automatisch neue Container-Instanzen deiner App, um die Last zu verteilen. Geht der Traffic zurück, werden die unnötigen Instanzen wieder heruntergefahren, um Ressourcen zu sparen.
Selbstheilung: Fällt ein Container (oder sogar ein ganzer Server!) aus, erkennt Kubernetes das und startet automatisch Ersatz-Container auf einem anderen, gesunden Server. Deine App bleibt erreichbar.
Automatisierte Rollouts & Rollbacks: Neue Versionen deiner App werden schrittweise ausgerollt. Tritt ein Fehler auf, kann Kubernetes automatisch zur vorherigen, stabilen Version zurückrollen. Ohne Downtime!
Ressourcenmanagement: Kubernetes weist Containern automatisch die benötigten CPU- und Speicherressourcen zu und optimiert die Auslastung deiner Server.
Service Discovery und Load Balancing: Kubernetes sorgt dafür, dass deine einzelnen App-Komponenten (z.B. Frontend und Backend) einander finden können und verteilt den Netzwerkverkehr intelligent auf die verschiedenen Instanzen deiner App.
Speicher-Orchestrierung: Es kann Speicherlösungen (lokal, Cloud-Storage, Netzwerk-Speicher) nahtlos in deine Container integrieren.
Geheimnis- und Konfigurationsmanagement: Sensible Daten wie Passwörter oder API-Keys sowie Konfigurationsdateien können sicher verwaltet und den Containern zur Verfügung gestellt werden.

3. Die Kernkomponenten von Kubernetes (stark vereinfacht)

Ein Kubernetes-Cluster besteht grob aus zwei Hauptteilen:

Der Control Plane (Steuerungsebene / "Das Gehirn"): Hier laufen die Komponenten, die den Cluster steuern und verwalten. Es ist die zentrale Instanz, die entscheidet, wo welcher Container läuft, wie viele Instanzen es gibt und ob alles in Ordnung ist.
Die Worker Nodes (Arbeitsknoten / "Die Arbeiter"): Das sind die Server (virtuell oder physisch), auf denen deine tatsächlichen Container ausgeführt werden. Jeder Worker Node hat einen Agenten, der mit dem Control Plane kommuniziert und die Befehle ausführt.

Innerhalb dieser Architektur sprechen wir dann von weiteren wichtigen Konzepten:

Pod: Die kleinste, deploybare Einheit in Kubernetes. Ein Pod ist ein Wrapper für einen oder mehrere Container, die eng miteinander verbunden sind und gemeinsam verwaltet werden. Stell dir einen Pod wie eine "Wohnung" vor, in der deine Container ("Bewohner") leben.
Deployment: Ein Deployment ist eine Anleitung für Kubernetes, wie viele Pods deiner Anwendung laufen sollen und welche Version. Es verwaltet die Lebenszyklen deiner Pods und sorgt für Skalierung und Selbstheilung. Stell dir ein Deployment wie den "Manager eines Wohnkomplexes" vor, der sicherstellt, dass immer die richtige Anzahl an Wohnungen bewohnt ist.
Service: Ein Service definiert, wie du auf eine Gruppe von Pods zugreifen kannst (z.B. über eine interne oder externe IP-Adresse und einen Port). Egal, welche Pods gerade laufen oder wo sie sich befinden, der Service sorgt dafür, dass du sie immer erreichst. Der "Postbote", der sicherstellt, dass deine Briefe immer die richtige Wohnung erreichen, auch wenn die Mieter umziehen.

4. Wie fange ich an? Installation für Einsteiger (Minikube)

Die vollständige Installation eines Produktions-Kubernetes-Clusters ist komplex. Für den Einstieg gibt es aber hervorragende Tools, die einen lokalen Mini-Cluster auf deinem eigenen Rechner aufsetzen. Wir empfehlen Minikube (oder Docker Desktop, falls du es schon nutzt).

Voraussetzungen:

Virtualisierungssoftware: VirtualBox, Hyper-V (Windows), KVM (Linux) oder Docker Desktop (Windows/Mac).
kubectl: Das Kommandozeilen-Tool, um mit deinem Kubernetes-Cluster zu kommunizieren.

Schritt-für-Schritt mit Minikube:

Installieren von kubectl: Folge der offiziellen Anleitung für dein Betriebssystem: https://kubernetes.io/docs/tasks/tools/install-kubectl/
Installieren von Minikube: Folge der offiziellen Anleitung für dein Betriebssystem: https://minikube.sigs.k8s.io/docs/start/

Kurzfassung (Beispiel macOS mit Homebrew, oder Windows mit Chocolatey):
```
# macOS
brew install minikube
```
```
# Windows mit Chocolatey (als Administrator ausführen)
choco install minikube
```
Starte deinen ersten Kubernetes-Cluster: Öffne ein Terminal oder eine Kommandozeile und gib ein:
```
minikube start
```
Dies kann einige Minuten dauern, da Minikube eine virtuelle Maschine erstellt und Kubernetes darin installiert.
Überprüfe den Status:
```
kubectl cluster-info
kubectl get nodes
```
Du solltest sehen, dass dein Minikube-Node läuft.
Öffne das Kubernetes-Dashboard (optional, aber nützlich):
```
minikube dashboard
```
Dies öffnet das Web-Dashboard in deinem Browser, wo du einen visuellen Überblick über deinen Cluster bekommst.

5. Erste Schritte: Dein erster Pod und Deployment

Jetzt, wo dein Cluster läuft, lassen wir unsere erste Anwendung darin laufen!

Dein erster Pod (direkt – nur zum Verständnis, nicht für Produktion!)

Wir starten einen einfachen Nginx-Webserver in einem Pod:

kubectl run my-nginx-pod --image=nginx --port=80

kubectl run: Befehl zum Starten einer App.
my-nginx-pod: Der Name, den wir unserem Pod geben.
--image=nginx: Das Docker-Image, das wir verwenden (ein einfacher Webserver).
--port=80: Der Port, den der Container intern exponiert.

Status überprüfen:

kubectl get pods

Du solltest sehen, dass dein my-nginx-pod den Status Running hat.

Pod löschen:

kubectl delete pod my-nginx-pod

Ein realistischerer Anwendungsfall: Deployment und Service

Wie bereits erwähnt, ist das direkte Erstellen von Pods für die meisten Anwendungsfälle nicht ideal. Wir nutzen Deployments, um Pods zu verwalten, und Services, um sie erreichbar zu machen.

Erstelle eine Datei namens nginx-deployment.yaml mit folgendem Inhalt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3 # Wir möchten 3 Instanzen unseres Nginx-Servers
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  type: NodePort # Dies macht den Service von außerhalb des Clusters erreichbar
  ports:
    - port: 80 # Der Port des Services
      targetPort: 80 # Der Port, den die Pods exponieren
      nodePort: 30080 # Ein Port auf dem Host-Server (muss im Bereich 30000-32767 liegen)

Erklärung der YAML-Datei:

Deployment:
- kind: Deployment: Sagt Kubernetes, dass dies ein Deployment ist.
- replicas: 3: Wir wollen, dass 3 Nginx-Pod-Instanzen gleichzeitig laufen.
- selector und template/metadata/labels: Definiert, welche Pods zu diesem Deployment gehören (app: nginx).
- containers: Spezifiziert den Container, der in den Pods laufen soll (Nginx-Image auf Port 80).
Service:
- kind: Service: Sagt Kubernetes, dass dies ein Service ist.
- selector: app: nginx: Dieser Service wird alle Pods finden, die das Label app: nginx haben (also unsere Nginx-Pods).
- type: NodePort: Macht den Service von außen über einen speziellen Port auf dem Minikube-Host erreichbar.
- port: 80: Der Port des Services.
- targetPort: 80: Der Port des Containers, zu dem der Traffic weitergeleitet wird.
- nodePort: 30080: Der Port auf deiner Hostmaschine (Minikube VM), über den du den Service erreichen kannst.

Anwenden der Konfiguration:

kubectl apply -f nginx-deployment.yaml

Status überprüfen:

kubectl get deployments
kubectl get pods -l app=nginx # Zeigt nur unsere Nginx-Pods
kubectl get services

Du solltest 3 Nginx-Pods sehen und einen Service namens nginx-service.

Zugriff auf die Anwendung: Da wir einen NodePort-Service erstellt haben, können wir die Anwendung über die IP-Adresse deines Minikube-Clusters und den nodePort erreichen.

Die Minikube-IP-Adresse findest du mit:

minikube ip

Nehmen wir an, die IP ist 192.168.49.2. Dann kannst du deinen Nginx-Webserver im Browser unter http://192.168.49.2:30080 aufrufen. Du solltest die Standard-Nginx-Willkommensseite sehen!

Aufräumen: Um alles zu löschen, was wir gerade erstellt haben:

kubectl delete -f nginx-deployment.yaml

Um den Minikube-Cluster zu stoppen und zu löschen:

minikube stop
minikube delete

Fazit und Nächste Schritte

Herzlichen Glückwunsch! Du hast soeben deine ersten Schritte in der Welt von Kubernetes gemacht. Du hast gelernt, was Kubernetes ist, welche Probleme es löst und wie du eine einfache Anwendung auf einem lokalen Cluster bereitstellen kannst.

Kubernetes ist ein mächtiges und komplexes Tool, aber die Grundlagen sind mit etwas Übung gut zu erlernen. Lass dich nicht entmutigen, wenn nicht alles sofort klar ist. Die Lernkurve ist steil, aber die Vorteile sind enorm.

Was kommt als Nächstes?

Erforsche weitere Kubernetes-Ressourcen: Ingress, ConfigMaps, Secrets, Volumes.
Tiefer in YAML eintauchen: Verstehe die Struktur und Möglichkeiten der Konfigurationsdateien.
Produktionsbereite Cluster: Beschäftige dich mit Cloud-Anbietern wie Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS) oder Azure Kubernetes Service (AKS), die verwaltete Kubernetes-Dienste anbieten.
Lerne mehr über Helm: Ein Paketmanager für Kubernetes, der die Bereitstellung komplexer Anwendungen vereinfacht.
Schau dir die offizielle Dokumentation an: https://kubernetes.io/docs/home/

Die Reise in die Welt der Container-Orchestrierung hat gerade erst begonnen. Viel Erfolg beim weiteren Entdecken und Experimentieren!

Kubernetes für Einsteiger