Kubernetes für Entwickler: Praxis und Debugging

Praktische Einführung in Kubernetes: Vom lokalen Cluster zur Cloud-Bereitstellung

Kubernetes ist nicht nur ein Tool zur Container-Orchestrierung – es ist der De-facto-Standard zur Verwaltung verteilter Anwendungen. Dieser Artikel richtet sich an Entwickler und Ingenieure, die schnell von der Theorie zur Praxis kommen möchten: einen lokalen Cluster bereitstellen, die grundlegenden Objekte verstehen und sich auf verwaltete Cloud-Dienste vorbereiten.

Einrichtung Ihrer Arbeitsumgebung

Der erste Schritt ist die Installation von kubectl, dem primären CLI-Tool zur Interaktion mit der Kubernetes-API. Die Client-Version sollte sich von der Cluster-Version um höchstens eine Minor-Release-Branch unterscheiden. Die Installation variiert je nach Betriebssystem:

• Linux: offizielles Skript aus dem Kubernetes-Repository;
• macOS: brew install kubectl;
• Windows: über winget, Chocolatey oder direkten Binärdownload.

Wichtig: Bei Verwendung von Docker Desktop kann das integrierte kubectl mit dem Haupttool kollidieren. Es wird empfohlen, einen einzigen Installationspunkt zu verwenden und die PATH-Variable zu verwalten.

Für die lokale Entwicklung eignen sich zwei Lösungen gut:

Minikube

Minikube erstellt einen Single-Node-Cluster in einer virtuellen Maschine oder einem Container (je nach Driver). Starten Sie ihn mit einem Befehl:

minikube start

Nach dem Start überprüfen Sie den Knotenstatus:

kubectl get nodes

Erwartetes Ergebnis: ein Knoten mit Ready-Status.

Kind (Kubernetes in Docker)

Kind führt Knoten als Docker-Container aus. Das ist besonders praktisch bei enger Integration in bestehende Docker-Workflows:

kind create cluster

Die Vorteile von Kind umfassen schnellen Start und einfache Bereinigung. Für Anfänger bleibt Minikube jedoch die bevorzugte Wahl aufgrund seiner umfangreichen Dokumentation und Community.

Nach dem Starten des Clusters überprüfen Sie die Konnektivität:

kubectl cluster-info

Wenn der Befehl Infos zu den Control-Plane-Komponenten zurückgibt, ist Ihre Umgebung bereit.

Grundlegende Kubernetes-Objekte

Jede Anwendung in Kubernetes basiert auf drei Schlüssabstraktionen: Pod, Deployment und Service.

Pod — die minimale ausführbare Einheit

Ein Pod ist eine Gruppe aus einem oder mehreren Containern, die Netzwerknamespace, Volumes und IPC teilen. Alle Container in einem Pod können einander über localhost erreichen. Pods sind jedoch flüchtig: Sie können jederzeit aufgrund von Fehlern, Updates oder Skalierung gelöscht werden. Direkte Pod-Verwaltung wird nicht empfohlen.

Deployment — deklarative Replikaverwaltung

Ein Deployment definiert den gewünschten Zustand einer Anwendung: Anzahl der Replicas, Container-Image, Update-Strategie. Beispiel-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:v1.2
        ports:
        - containerPort: 80

Das Manifest anwenden:

kubectl apply -f deployment.yaml

Kubernetes erstellt automatisch einen ReplicaSet, der die angegebene Anzahl laufender Pods sicherstellt.

Service — stabiler Netzwerk-Einstiegspunkt

Ein Service stellt eine stabile IP-Adresse und DNS-Name für eine Gruppe von Pods bereit, die per Labels ausgewählt werden. Beispiel für einen internen Service:

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - port: 8080
      targetPort: 80
  type: ClusterIP

Für lokalen Zugriff in Minikube verwenden:

minikube service my-app-service

Der Befehl öffnet automatisch einen Browser mit der korrekten URL.

Übergang zur Cloud: Verwaltete Cluster

Nach der Beherrschung der lokalen Umgebung ist es naheliegend, zu Produktionsbereitstellungen überzugehen. Manuelle Cluster-Einrichtung mit kubeadm ist möglich, aber für die meisten Szenarien unpraktisch. Besser verwaltete Dienste nutzen:

• Amazon EKS — flexibel, erfordert aber tiefes Wissen über AWS IAM und VPC;
• Google GKE — die ausgereifteste Implementierung mit automatischer Knotenverwaltung und integrierter Sicherheit;
• Azure AKS — bequem bei Nutzung des Microsoft-Ökosystems und Azure DevOps.

Der empfohlene Ansatz ist Infrastructure as Code (IaC). Mit Terraform können Sie den Cluster und die Node-Gruppe deklarativ beschreiben – für Reproduzierbarkeit und Versionskontrolle.

Nach der Erstellung des Clusters in der Cloud aktualisieren Sie kubeconfig:

aws eks update-kubeconfig --name my-app-cluster

Nun zielen alle kubectl-Befehle auf den Cloud-Cluster ab.

Debugging gängiger Probleme

Kubernetes-Fehler folgen oft wiederkehrenden Mustern. Folgen Sie einem systematischen Ansatz:

• Pod-Status prüfen: kubectl get pods
• Logs überprüfen: kubectl logs <pod-name>
• Ereignisse analysieren: kubectl describe pod <pod-name>
• Bei Bedarf in den Container eintreten: kubectl exec -it <pod-name> -- /bin/sh

Gängige Probleme und Lösungen:

• ImagePullBackOff: Image-Name, Tag und imagePullSecrets für private Repos überprüfen;
• CrashLoopBackOff: App-Logs und Ereignisse auf OOMKilled oder Init-Fehler prüfen;
• Service nicht erreichbar: Sicherstellen, dass Pod-Labels zum Service-Selector passen und Ports (port, targetPort, containerPort) übereinstimmen.

Geben Sie immer resources.requests und resources.limits für CPU und Speicher an – das verhindert Knoteninstabilität und schlechte Planung.

Was als Nächstes lernen

Nach dem Verständnis der Grundlagen konzentrieren Sie sich auf:

• Ingress und Gateway API — Routing externen Traffics;
• ConfigMaps und Secrets — Konfigurationsverwaltung ohne Hardcoding;
• Jobs und CronJobs — einmalige und periodische Aufgaben;
• Horizontal Pod Autoscaler — metrikbasierte Auto-Skalierung.

Das Kubernetes-Ökosystem ist dynamisch: Neue Standards (wie Gateway API) ersetzen allmählich veraltete. Bleiben Sie auf dem Laufenden, priorisieren Sie aber die Lösung spezifischer Probleme vor dem Lernen von allem auf einmal.

Wichtige Erkenntnisse

• Kubernetes erfordert einen deklarativen Ansatz: Beschreiben Sie den gewünschten Zustand, und das System arbeitet darauf hin.
• Lokale Cluster (Minikube, Kind) bieten einen sicheren Spielplatz für Experimente ohne Produktionsrisiken.
• Verwaltete Cloud-Dienste (EKS, GKE, AKS) sparen Hunderte von Stunden Ops-Aufwand.
• Debugging beginnt mit kubectl get, describe und logs – das löst 90 % der Probleme.
• Setzen Sie immer Ressourcenlimits, um Cluster-Instabilität zu vermeiden.

— Editorial Team