Was ist Kubernetes? Eine Einführung mit Beispielen

Wenndu den Aufschwung des Cloud Computing kennst, hast du sicher schon von Kubernetes gehört. In der modernen Anwendungsentwicklung ist es ein wichtiges Werkzeug, das du für die Verwaltung verschiedener Infrastrukturen lernen musst.

In diesem Einführungsartikel geben wir dir einen Überblick über Kubernetes und seine Komponenten sowie eine umfassende Anleitung zur lokalen Implementierung. Wenn du ergänzend zu diesem Tutorium eine praktische Lernerfahrung suchst, schau dir unseren Kurs Einführung in Kubernetes an. 

Was ist Kubernetes?

Kubernetes ist eine Open-Source-Plattform zur Orchestrierung von Containern, die die Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen automatisiert. Ursprünglich von Google entwickelt, hat es sich zum De-facto-Standard für den Betrieb von Containern im großen Maßstab entwickelt.

Es abstrahiert die Komplexität der Verwaltung einzelner Container und ermöglicht es Entwicklern, sich auf die Erstellung und Bereitstellung ihrer Anwendungen zu konzentrieren.

Warum Kubernetes verwenden?

Hier sind einige der wichtigsten Vorteile von Kubernetes:

• Container-Orchestrierung: Automatisiert die Verteilung und Planung von Containern innerhalb eines Clusters.
• Skalierbarkeit und Selbstheilung: Vereinfacht die horizontale Skalierung (Replikation von Containern) und vertikale Skalierung (Anpassung der Ressourcenzuweisung) mit Selbstheilungsfunktionen.
• Hohe Verfügbarkeit: Stellt sicher, dass Container (und damit deine Dienste) auch dann betriebsbereit bleiben, wenn einige Knotenpunkte ausfallen.
• Tragbarkeit: Abstrahiert die zugrundeliegende Infrastruktur, sodass sie sowohl vor Ort als auch bei verschiedenen Cloud-Anbietern betrieben werden kann.
• Effiziente Ressourcennutzung: Ändert die Größe von Containern basierend auf der Ressourcennutzung, optimiert die Ressourcenzuweisung und senkt die Kosten.

Kubernetes ist nützlich für verschiedene Anwendungen wie:

• DevOps: Automatisiert die Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen.
• Microservices: Zerlegt große monolithische Anwendungen in kleinere, überschaubare Dienste, um die Agilität und Skalierbarkeit zu verbessern.
• Große Daten: Vereinfacht die Bereitstellung und Verwaltung komplexer Big-Data-Systeme mithilfe von Containern.
• Edge Computing: Ermöglicht den Betrieb von Kubernetes auf Edge-Geräten, um Daten näher am Entstehungsort zu verarbeiten und zu analysieren, wodurch Latenzzeiten reduziert und die Leistung verbessert werden.
• Kontinuierliche Lieferung: Integriert mit Tools wie Jenkins und GitLab für automatisierte Continuous Delivery Pipelines.
• Maschinelles Lernen: Bietet eine skalierbare Plattform für das Training und den Einsatz von Machine-Learning-Modellen, die Verarbeitung großer Datensätze und komplexe Berechnungen.

Schlüsselkonzepte in Kubernetes

Um zu verstehen, wie Kubernetes funktioniert, brauchst du ein gutes Verständnis der wichtigsten Konzepte. 

Dazu gehören 4 Hauptkonzepte:

1. Clusters
2. Schoten
3. Namespaces
4. Betreiber

Wir werden weiter unten mehr darüber erfahren.

Clusters

Kubernetes-Cluster sind Gruppen von Nodes, also einzelnen Maschinen, auf denen die Kubernetes-Software läuft. Der Cluster fungiert als Kontrollebene für die Verwaltung von Anwendungen und Diensten.

In einer typischen Konfiguration hat ein Cluster einen Master-Knoten und mehrere Worker-Knoten. Der Master-Knoten ist für die Koordinierung aller Aktivitäten innerhalb des Clusters zuständig, während die Worker-Knoten die Ausführung und Verwaltung der Container übernehmen.

Schoten

Pods sind die kleinste Einheit für die Bereitstellung in Kubernetes. Sie können einen oder mehrere Container enthalten, zusammen mit gemeinsamen Speicherressourcen und Netzwerkeinstellungen.

Jeder Pod hat eine eigene, eindeutige IP-Adresse und kann über diese Adresse mit anderen Pods im selben Cluster kommunizieren. Dies ermöglicht eine effiziente Kommunikation zwischen verschiedenen Komponenten einer Anwendung.

Pods gibt es entweder als Einzel- oder als Multicontainer-Pods und jeder hat seinen eigenen Anwendungsfall.

• Einzelbehälter-Pods: Die häufigste Art von Pods, in denen ein einzelner Container läuft. Dies ist nützlich für einfache Anwendungen oder Microservices, die nur einen Container benötigen.
• Multicontainer-Pods: Mehrere Container werden zusammen aufgestellt und gemeinsam betrieben. Dies kann für komplexe Anwendungen von Vorteil sein, bei denen verschiedene Container miteinander kommunizieren und Ressourcen gemeinsam nutzen müssen.

Namespaces

Namespaces bieten eine Möglichkeit, Ressourcen innerhalb eines Clusters logisch zu partitionieren. Dies ermöglicht eine bessere Organisation und Verwaltung der Ressourcen sowie strengere Sicherheitskontrollen.

Namespaces können auch verwendet werden, um verschiedene Umgebungen zu verwalten, z. B. Entwicklung, Staging und Produktion. Dadurch wird sichergestellt, dass die Ressourcen isoliert sind und nicht durch Änderungen in anderen Umgebungen beeinträchtigt werden.

Um die Namespaces in deinem Cluster anzuzeigen, kannst du diesen Befehl verwenden:

kubectl get namespaces

Um zwischen den Namespaces zu wechseln, kannst du Folgendes tun

kubectl config set-context --current --namespace <namespace name>

Betreiber

Operatoren sind Software-Erweiterungen, die dabei helfen, die Verwaltung von Kubernetes-Ressourcen zu automatisieren. Sie verwenden benutzerdefinierte Controller und API-Erweiterungen, um komplexe Aufgaben effizienter und automatisch zu verwalten.

Einige beliebte Anbieter sind:

• Prometheus für die Überwachung
• etcd-Operator für die Verwaltung von etcd-Clustern

Die Verwendung von Operatoren kann die Verwaltung von Anwendungen und Ressourcen innerhalb deines Clusters erheblich vereinfachen. Dank ihrer Fähigkeit, Aufgaben zu automatisieren und erweiterte Funktionen bereitzustellen, werden sie bei Kubernetes-Nutzern immer beliebter.

Kernkomponenten von Kubernetes

In den meisten Kubernetes-Umgebungen gibt es eine Reihe von Kernkomponenten.

Quelle: Kubernetes

Hier ist eine Liste der Komponenten und ihrer Funktionen:

1. API Server: Diese Komponente fungiert als zentraler Verwaltungspunkt für alle Kubernetes-Ressourcen. Sie erhält Anfragen von Nutzern und anderen Komponenten und setzt dann Richtlinien zur Verwaltung des Clusters durch.
2. Controller Manager: Der Controller Manager ist dafür verantwortlich, den gewünschten Zustand des Clusters aufrechtzuerhalten, indem er Änderungen an Objekten innerhalb des Clusters ständig überwacht und abgleicht.
3. etcd: Dies ist ein verteilter Key-Value-Store, der als primärer Datenspeicher für Kubernetes dient. Sie speichert alle Daten des Clusters und stellt die Konsistenz und Verfügbarkeit der Daten sicher.
4. kubelet: Dieser Agent läuft auf jedem Knoten im Cluster und ist für die Verwaltung von Containern zuständig. Er stellt sicher, dass sie gemäß ihrer festgelegten Konfigurationen laufen.
5. Kube Proxy: Diese Komponente läuft auf jedem Knotenpunkt und ist für die Weiterleitung des Netzwerkverkehrs an den richtigen Container verantwortlich.

Wie Kubernetes funktioniert

Wie wir bereits festgestellt haben, automatisiert Kubernetes die Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen in Clustern. Sie sorgt für hohe Verfügbarkeit, effiziente Ressourcennutzung und Selbstheilung ohne manuelle Eingriffe.

Anstatt einzelne Container zu verwalten, fasst Kubernetes sie in Pods zusammen und verteilt sie auf Worker Nodes, die mit der Control Plane kommunizieren, um den gewünschten Zustand des Systems aufrechtzuerhalten.

So funktioniert Kubernetes, kurz und bündig:

1. Definiere den Einsatz der Anwendung: Du legst den gewünschten Status in einer YAML-Datei fest, einschließlich Replikate, Ressourcenlimits und Netzwerkregeln.
2. Plane die Arbeitsbelastung: Der Scheduler weist die Pods je nach Verfügbarkeit der Ressourcen den Arbeitsknoten zu.
3. Verwalte den Zustand des Clusters: Der Controller Manager sorgt dafür, dass das System die richtige Anzahl von Pods aufrechterhält und ersetzt alle, die ausfallen.
4. Vernetzungen handhaben: Kubernetes verwaltet die Kommunikation zwischen den Diensten und den externen Zugriff über Services und Ingress-Controller.
5. Skalieren und selbst heilen: Kubernetes passt die Anzahl der laufenden Pods je nach Bedarf an und startet ausgefallene Container automatisch neu.

Da Kubernetes die Komplexität der Infrastruktur bewältigt, können sich die Teams auf die Entwicklung von Anwendungen konzentrieren, anstatt die Bereitstellung zu verwalten. Das macht Kubernetes zu einem unverzichtbaren Werkzeug für skalierbare, belastbare Workloads in allen Branchen.

Gemeinsame Terminologie und Konzepte

Schauen wir uns einige der wichtigsten Begriffe an, die du kennen musst, und ihre Definitionen:

• YAML-Manifeste: Das sind Konfigurationsdateien, die den gewünschten Zustand deiner Anwendung oder Infrastruktur definieren. Sie können verwendet werden, um Ressourcen in Kubernetes zu erstellen, zu aktualisieren und zu löschen.
• StatefulSets vs. Einsätze: Es gibt zwei Arten von Controllern in Kubernetes, die den Lebenszyklus von Pods verwalten. Deployments werden normalerweise für zustandslose Anwendungen verwendet, während StatefulSets für zustandsabhängige Anwendungen verwendet werden.
• Dienstleistungen: Diese bieten eine stabile IP-Adresse und einen DNS-Namen für den Zugriff auf deine Anwendung innerhalb des Clusters. Sie ermöglichen auch die Kommunikation zwischen verschiedenen Pods.
• ConfigMaps: Diese werden verwendet, um Konfigurationsdaten in Schlüssel-Wert-Paaren zu speichern, auf die deine Anwendung zugreifen kann.
• Geheimnisse: Ähnlich wie ConfigMaps werden diese verwendet, um sensible Informationen wie Passwörter oder API-Schlüssel zu speichern.

Erste Schritte mit Kubernetes

Die Arbeit mit Kubernetes kann entmutigend wirken, vor allem wenn es darum geht, die verschiedenen Begriffe und Konzepte zu verstehen. Wenn du diese grundlegenden Begriffe jedoch erst einmal verstanden hast, wird es viel einfacher, sich auf der Plattform zurechtzufinden.

Schauen wir uns zunächst einige Tools an, die mit Kubernetes verwendet werden.

Tools für Anfänger

Als Kubernetes-Anfänger ist man mit der Bereitstellung von Anwendungen in der Cloud oft überfordert. Du kannst also auf einige gängige Tools zurückgreifen, um sie lokal einzusetzen. 

Hier sind 2 der am häufigsten verwendeten Werkzeuge:

1. Minikube

Minikube ist eine leichtgewichtige Kubernetes-Implementierung, die auf einem einzigen Host-Rechner laufen kann. Normalerweise läuft ein Single-Node-Cluster in einer virtuellen Maschine (VM) auf deinem Laptop oder deiner Workstation.

Warum es verwenden:

• Leicht auf- und abzubauen.
• Ideal für die lokale Entwicklung und für Proofs-of-Concept.
• Minimaler Ressourcenverbrauch im Vergleich zu einem vollwertigen Cluster.

So installierst du Minikube (Beispiel unter Windows):

# Install via Windows Package Manager
winget install Kubernetes.minikube

Du solltest die folgende Installationsmeldung sehen können. Stimme den Geschäftsbedingungen zu, wenn du mit "J" gefragt wirst.

Um einen einfachen Cluster auf minikube zu starten, verwende den folgenden start Befehl:

# Start a single-node cluster
minikube start

Um zu überprüfen, ob der Clusterknoten erfolgreich gestartet wurde, führe den Befehl get aus:

# Verify the cluster is running
kubectl get nodes

Hinweis: Du musst den kubectl API Server auf deinem lokalen Rechner installiert haben (er wird in vielen Fällen automatisch mit Minikube installiert).

2. Kind (Kubernetes in Docker)

Kind steht für Kubernetes in Docker. Es verwendet Docker-Container als "Knoten" in einem Kubernetes-Cluster und bietet eine einfache, containerbasierte lokale Cluster-Umgebung.

Warum es verwenden:

• Schnelleres Starten im Vergleich zu Minikube in vielen Szenarien.
• Es ist einfach, mehrere Testcluster gleichzeitig zu starten, ideal für CI/CD-Pipelines.
• Wird oft in automatisierten Testumgebungen verwendet, da es weniger Aufwand bedeutet.

So installierst du Kind (Beispiel unter Windows):

# Install Kind with Windows Package Manager
winget install Kubernetes.kind

Nach der Installation kannst du mit dem Befehl create cluster einen einfachen Cluster erstellen und ihm einen Namen geben.

# Create a basic cluster
kind create cluster --name example-cluster

Um zu überprüfen, ob dein Kubernetes-Art-Cluster gestartet ist, verwende den folgenden get Befehl.

# Check running clusters
kind get clusters

Du kannst auch über die Schnittstelle kubectl mit dem Cluster interagieren:

# Interact with your Kind cluster using kubectl
kubectl get nodes

Hinweis: Stelle sicher, dass du Docker installiert hast und es läuft.

Cloud-Anbieter (EKS, GKE, AKS)

Wenn du Kubernetes in der Cloud betreiben willst, gibt es einige Cloud-Anbieter, die du auswählen kannst:

1. Amazon EKS (Elastic Kubernetes Service)

Amazon EKS ist ein verwalteter Service, der den Betrieb von Kubernetes auf AWS vereinfacht, ohne dass du deine eigene Control Plane oder Worker Nodes verwalten musst. Es lässt sich in andere AWS-Services integrieren, um zusätzliche Funktionen wie Lastverteilung, Speicherung, automatische Skalierung und Überwachung zu nutzen.

Einige zusätzliche Funktionen sind:

• Bietet Integrationen mit anderen AWS-Diensten (z. B. IAM, CloudWatch, ECR).
• Skalierbarkeit und hohe Verfügbarkeit sind in die Plattform integriert.

2. Google GKE (Google Kubernetes Engine)

Google GKE ist ein vollständig verwalteter Service für den Betrieb von Kubernetes auf der Google Cloud Platform. Sie bietet automatische Skalierung, Selbstheilungsfunktionen und die Integration mit anderen Google Cloud-Diensten.

Einige zusätzliche Funktionen sind:

• Tiefe Integration mit GCP-Diensten wie Cloud Logging, Cloud Monitoring und Container Registry.
• Bietet einen Autopilot-Modus, der die Cluster-Infrastruktur automatisch verwaltet.

3. Azure AKS (Azure Kubernetes Service)

Azure AKS bietet serverlose Kubernetes-Cluster, die vollständig mit anderen Azure-Diensten wie Storage, Networking und Load Balancing integriert sind. Außerdem bietet es integrierte Unterstützung für DevOps-Tools wie Helm und Prometheus.

Einige zusätzliche Funktionen sind:

• Integriert mit Azure Active Directory, Azure Monitor, Container Registry, etc.
• Bietet serverlose Kubernetes (Virtual Nodes) mit Azure Container Instances.

Ressourcen zum Erlernen von Kubernetes

Kubernetes zum ersten Mal zu lernen, kann überwältigend erscheinen, aber es gibt viele Ressourcen, die dir den Einstieg erleichtern. 

Hier sind einige empfohlene Ressourcen:

• DataCamp Kurse und Ressourcen: Unser Kurs "Einführung in Kubernetes" und unser Containerisierungs-Tutorial sind gute Ausgangspunkte.
• Unsere speziellen Kubernetes-Starter-Tutorials: Erstellt, um dich mit den Grundlagen zu versorgen.

Beispiel für den Kubernetes-Einsatz

Um Anwendungen in Kubernetes auszuführen, folgst du einem strukturierten Arbeitsablauf, der das Einrichten eines Clusters, die Bereitstellung einer containerisierten Anwendung, die Bereitstellung als Dienst und die Skalierung nach Bedarf umfasst. 

Wir haben diesen Prozess in unserem Kubernetes-Tutorial ausführlich beschrieben, aber hier ist eine kurze Zusammenfassung:

Einen Kubernetes-Cluster einrichten

Verwende Minikube, um einen lokalen Cluster für Tests und Entwicklung zu erstellen. Installiere Minikube und starte deinen Cluster mit:

minikube start --driver=docker

kubectl get nodes

Eine Anwendung bereitstellen

Definiere den gewünschten Zustand deiner Anwendung in einer Deployment YAML-Datei. Die Einrichtung eines Nginx-Webservers sieht zum Beispiel so aus:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
      - name: hello-container
        image: nginx:latest
        ports:
        - containerPort: 80

Wende den Einsatz mit an:

kubectl apply -f hello-deployment.yaml

Stelle die Anwendung als Dienst zur Verfügung

Um die Anwendung zugänglich zu machen, erstelle einen Dienst mit:

kubectl expose deployment hello-deployment --type=NodePort --port=80 --name=hello-service

Rufe die externe URL ab und öffne die App in deinem Browser:

minikube service hello-service

Skalierung und Überwachung der Anwendung

Kubernetes ermöglicht es dir, Anwendungen mühelos zu skalieren. Um die Anzahl der Replikate zu erhöhen:

kubectl scale deployment hello-deployment --replicas=3

Prüfe laufende Pods:

kubectl get pods

Sieh dir die Protokolle für die Fehlersuche an:

kubectl logs -f <pod-name>

Hier sind einige Beispiele, die du für fortgeschrittene Projekte weiter untersuchen kannst:

• Führe Streaming-Jobs in Containern aus (z. B. Spark auf Kubernetes, Kafka auf Kubernetes).
• verwenden Persistent Volumes um externe Speicherlösungen wie AWS EBS, Azure Disks oder NFS einzubinden.
• Komplexere Anwendungen bereitstellen (z. B. mehrschichtige Microservices mit Datenbanken).
• Erforsche fortgeschrittene Funktionen wie Ingress-Controller, Service Meshes (z. B. Istio), Helm-Diagramme für die Paketverwaltung.

Fazit

Kubernetes ist eine leistungsstarke Plattform für die Bereitstellung und Verwaltung von containerisierten Anwendungen im großen Maßstab und damit ein unverzichtbares Werkzeug für Dateningenieure, die elastische, zuverlässige Umgebungen für die Datenverarbeitung benötigen. 

Wenn du mehr über Kubernetes erfahren möchtest, kannst du unseren Kurs Einführung in Kubernetes ist der perfekte Ort, um damit anzufangen.