Einführung in Kubernetes: Der Container-Orchestrator

Wenn Sie in der Softwareentwicklung arbeiten, haben Sie sicherlich schon von Kubernetes gehört. Aber was genau ist es und warum ist es zum De-facto-Standard für die Verwaltung von containerisierten Anwendungen geworden? Diese Anleitung führt Sie von den Grundlagen zu den fundamentalen Konzepten, mit praktischen Beispielen und Diagrammen, die Ihnen das Verständnis erleichtern.

Vor Kubernetes: Ein kurzer historischer Rückblick

Um zu verstehen, warum Kubernetes so revolutionär ist, machen wir einen Schritt zurück.

1. Traditionelles Deployment: Anfangs wurden Anwendungen auf physischen Servern ausgeführt. Dieser Ansatz war teuer, schwer zu skalieren und anfällig für Ressourcenkonflikte.
2. Virtualisiertes Deployment: Dann kamen die Virtuellen Maschinen (VMs). VMs ermöglichten es, mehrere isolierte Anwendungen auf derselben Hardware auszuführen, was die Ressourcennutzung und Sicherheit verbesserte. Jede VM führt jedoch ein ganzes Betriebssystem aus und verbraucht viele Ressourcen.
3. Containerisiertes Deployment: Container (wie Docker) sind die nächste Entwicklungsstufe. Sie teilen sich dasselbe Host-Betriebssystem, führen aber isolierte Prozesse aus. Sie sind leichtgewichtig, schnell zu starten und portabel.

Container lösten das Portabilitätsproblem, schufen aber ein neues: Wie verwaltet man Hunderte (oder Tausende) von Containern in einer Produktionsumgebung? Wie stellt man sicher, dass sie immer laufen, miteinander kommunizieren können und je nach Last skalieren?

Hier kommt Kubernetes ins Spiel.

Was ist Kubernetes?

Kubernetes (oft als K8s abgekürzt) ist eine Open-Source-Plattform zur Orchestrierung von Containern. Vereinfacht ausgedrückt, automatisiert es das Deployment, die Skalierung und die Verwaltung von containerisierten Anwendungen. Von Google entwickelt und jetzt von der Cloud Native Computing Foundation (CNCF) gepflegt, ist Kubernetes zum unverzichtbaren Werkzeug für jeden geworden, der mit Microservices im großen Stil arbeitet.

Die Architektur eines Kubernetes-Clusters

Eine Kubernetes-Umgebung wird als Cluster bezeichnet. Ein Cluster besteht aus einer Reihe von Maschinen, den Nodes, auf denen unsere Anwendungen laufen. Die Architektur gliedert sich in zwei Hauptteile: die Control Plane und die Worker Nodes.

Control Plane

Die Control Plane ist das "Gehirn" des Clusters. Sie trifft globale Entscheidungen (wie das Scheduling) und erkennt und reagiert auf Cluster-Ereignisse. Ihre Hauptkomponenten sind:

• API Server (kube-apiserver): Das Gateway zum Cluster. Er stellt die Kubernetes-API bereit, die von Benutzern (über kubectl), Cluster-Komponenten und externen Tools zur Kommunikation verwendet wird.
• etcd: Eine konsistente und hochverfügbare Key-Value-Datenbank. Sie speichert alle Cluster-Daten und repräsentiert den gewünschten und aktuellen Zustand des Systems.
• Scheduler (kube-scheduler): Weist neu erstellte Pods einem verfügbaren Worker Node zu, unter Berücksichtigung von Ressourcenanforderungen, Richtlinien und anderen Einschränkungen.
• Controller Manager (kube-controller-manager): Führt Controller aus, das sind Kontrollschleifen, die den Zustand des Clusters überwachen und daran arbeiten, ihn in den gewünschten Zustand zu bringen. Zum Beispiel verwaltet der Node Controller die Nodes, während der Replication Controller sicherstellt, dass die richtige Anzahl von Pods läuft.

Worker Node

Worker Nodes sind die Maschinen (physisch oder virtuell), auf denen die Anwendungen tatsächlich ausgeführt werden. Jeder Node wird von der Control Plane verwaltet und enthält die folgenden Komponenten:

• Kubelet: Ein Agent, der auf jedem Node läuft. Er stellt sicher, dass die in den Pods beschriebenen Container laufen und fehlerfrei sind.
• Kube-proxy: Ein Netzwerk-Proxy, der die Netzwerkregeln auf den Nodes verwaltet. Er ermöglicht die Netzwerkkommunikation zu den Pods von Netzwerksitzungen innerhalb oder außerhalb des Clusters.
• Container Runtime: Die Software, die für die Ausführung von Containern verantwortlich ist. Docker ist am bekanntesten, aber Kubernetes unterstützt auch andere Runtimes wie containerd und CRI-O.

Grundlegende Kubernetes-Objekte

In Kubernetes wird alles durch Objekte dargestellt. Diese Objekte sind "Absichtserklärungen": Sobald Sie ein Objekt erstellen, arbeitet Kubernetes ständig daran, sicherzustellen, dass es existiert und dem gewünschten Zustand entspricht.

Hier sind die wichtigsten:

Pod

Der Pod ist die kleinste Ausführungseinheit in Kubernetes. Er repräsentiert einen oder mehrere Container, die zusammen auf demselben Node ausgeführt werden und Ressourcen wie Netzwerk und Speicher teilen.

Im Allgemeinen führen Sie nur einen Container pro Pod aus, aber in fortgeschrittenen Szenarien (wie "Sidecar-Containern" für Logging oder Monitoring) können Sie mehr haben.

Sie erstellen fast nie Pods direkt. Sie verwenden übergeordnete Abstraktionen wie Deployments.

Deployment

Ein Deployment ist das Objekt, das Sie am häufigsten verwenden werden. Es beschreibt den gewünschten Zustand für eine Gruppe identischer Pods. Der Deployment-Controller ist verantwortlich für:

• Das Erstellen und Verwalten eines ReplicaSet (ein anderes Objekt, das sicherstellt, dass eine bestimmte Anzahl von Replikaten eines Pods immer läuft).
• Das Skalieren der Anzahl der Pods nach oben oder unten.
• Die Verwaltung von Anwendungs-Updates auf kontrollierte Weise (z.B. Rolling Update), ohne Ausfallzeiten.

Hier ist eine Beispiel-YAML-Datei für ein Deployment, das 3 Replikate eines NGINX-Servers ausführt:

# nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Service

Pods in Kubernetes sind kurzlebig: Sie können jederzeit erstellt und zerstört werden. Jeder Pod hat seine eigene IP-Adresse, aber diese IP ist nicht stabil. Wie stellen wir also sicher, dass unsere Anwendung zuverlässig erreichbar ist?

Mit einem Service. Ein Service ist eine Abstraktion, die eine logische Menge von Pods und eine Richtlinie für den Zugriff darauf definiert. Er bietet einen stabilen Zugangspunkt (eine virtuelle IP-Adresse und einen DNS-Namen) für eine Gruppe von Pods.

Der Service verwendet einen selector basierend auf labels, um die Pods zu finden, an die er den Verkehr weiterleiten soll.

So erstellen Sie einen Service für unser NGINX-Deployment:

# nginx-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP # Standard - macht den Service nur innerhalb des Clusters verfügbar

Es gibt verschiedene Arten von Services:

• ClusterIP: Macht den Service unter einer cluster-internen IP verfügbar (Standard).
• NodePort: Macht den Service auf einem statischen Port auf jedem Worker Node verfügbar.
• LoadBalancer: Erstellt einen externen Load Balancer im Cloud-Anbieter (z.B. AWS, GCP) und weist dem Service eine öffentliche IP zu.

Ingress

Ein LoadBalancer-Service ist großartig, aber einen für jeden Service zu erstellen, kann teuer sein. Um mehrere HTTP/HTTPS-Dienste nach außen verfügbar zu machen, verwenden Sie einen Ingress.

Ein Ingress fungiert als "intelligenter Router" für externen Verkehr. Er ermöglicht es Ihnen, Routing-Regeln basierend auf dem Host (z.B. api.meineseite.com) oder dem Pfad (z.B. meineseite.com/api) zu definieren.

Hier ist ein Beispiel für einen Ingress:

# example-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
  - host: meineseite.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080
      - path: /ui
        pathType: Prefix
        backend:
          service:
            name: ui-service
            port:
              number: 3000

Weitere nützliche Objekte

• Namespace: Ermöglicht es Ihnen, "virtuelle Cluster" innerhalb eines physischen Clusters zu erstellen. Nützlich zur Isolierung von Umgebungen (z.B. development, staging, production) oder Teams.
• ConfigMap und Secret: Zur Verwaltung von Konfigurationsdaten und Geheimnissen (wie Passwörtern oder API-Schlüsseln), entkoppelt vom Container-Image.
• StatefulSet: Ähnlich wie ein Deployment, aber spezifisch für zustandsbehaftete Anwendungen (wie Datenbanken), die stabile Netzwerkidentitäten und persistenten Speicher benötigen.
• PersistentVolume (PV) und PersistentVolumeClaim (PVC): Zur Verwaltung von persistentem Speicher im Cluster.

Fazit

Kubernetes ist ein unglaublich mächtiges Werkzeug, aber die Lernkurve kann steil sein. Diese Anleitung hat nur an der Oberfläche gekratzt, aber wir hoffen, sie hat Ihnen ein solides Verständnis der grundlegenden Konzepte vermittelt.

Was nun?

• Lokal experimentieren: Installieren Sie Minikube oder Kind, um einen Kubernetes-Cluster auf Ihrem Computer zu erstellen.
• kubectl verwenden: Machen Sie sich mit dem kubectl-Befehl vertraut, Ihrem Hauptwerkzeug zur Interaktion mit dem Cluster. Versuchen Sie, das NGINX-Deployment und den Service aus diesem Artikel zu erstellen.
• Die offiziellen Tutorials erkunden: Die Kubernetes-Dokumentation ist eine fantastische Ressource voller Beispiele.

Container-Orchestrierung ist eine grundlegende Fähigkeit in der Cloud-nativen Welt, und die Beherrschung von Kubernetes wird Ihnen eine Welt voller Möglichkeiten eröffnen. Viel Spaß!