Was ist Kubernetes?

Willkommen zu unserem Guide über die Grundlagen von Kubernetes! Kubernetes, oft als K8s abgekürzt, ist eine Open-Source-Plattform, die für die automatische Bereitstellung, Skalierung und den Betrieb von Anwendungscontainern entwickelt wurde. Im Kern bietet Kubernetes ein Framework für den stabilen Betrieb verteilter Systeme, mit dem sich Aufgaben wie Ausfallsicherung, Skalierung und Bereitstellung effizient bewältigen lassen. Dabei werden die Container, aus denen eine Anwendung besteht, zur Vereinfachung der Verwaltung und Erkennung in logische Einheiten gruppiert.

Warum brauchen wir Kubernetes?

In der schnelllebigen digitalen Welt von heute streben Organisationen ständig nach mehr Effizienz und Agilität in der Anwendungsentwicklung und -verwaltung. Kubernetes erfüllt diese Anforderung, indem es den Prozess der Bereitstellung und Verwaltung komplexer Anwendungen vereinfacht. Es übernimmt die Skalierung und Ausfallsicherung von Anwendungen, stellt Bereitstellungsmuster bereit und vieles mehr. Das bedeutet, dass sich Entwickler auf ihre Anwendungen konzentrieren können, während Kubernetes sich um die betrieblichen Herausforderungen kümmert. Dadurch wird nicht nur die Produktivität verbessert, sondern auch die Zuverlässigkeit und Skalierbarkeit der Anwendungen erhöht.

Grundlegende Konzepte von Kubernetes

Container und Kubernetes

Ein Container ist ein leichtgewichtiges, eigenständiges Paket, das alles enthält, was zur Ausführung einer Software benötigt wird – einschließlich Code, Laufzeitumgebung, System-Tools, Bibliotheken und Einstellungen. Container sind voneinander und vom Hostsystem isoliert, wodurch sie portabel und über verschiedene Umgebungen hinweg konsistent sind.

Kubernetes geht bei der Containerisierung noch einen Schritt weiter: Es orchestriert diese Container. Es stellt sicher, dass sie dort laufen, wo und wann du es möchtest, und unterstützt sie dabei, bei Bedarf hochzuskalieren. Kubernetes bietet ein Framework für den stabilen Betrieb verteilter Systeme und verwaltet containerisierte Anwendungen auf mehreren Hosts. Es automatisiert die Bereitstellung, Skalierung und den Betrieb und erleichtert so die Verwaltung komplexer Anwendungen.

Nodes und Cluster verstehen

Im Zentrum von Kubernetes stehen zwei Schlüsselkonzepte: Nodes und Cluster.

• Nodes (Knoten): Ein Node ist die kleinste Recheneinheit im Kubernetes-Ökosystem. Dies kann eine physische oder eine virtuelle Maschine sein, auf der die Container ausgeführt werden. Jeder Node verfügt über die erforderlichen Dienste, um Container auszuführen und von Kubernetes verwaltet zu werden.
• Cluster: Ein Cluster ist eine Gruppe von Nodes. Hier laufen alle von Kubernetes verwalteten Container-Anwendungen. Ein Cluster bietet die hohe Verfügbarkeit, Skalierbarkeit und Redundanz, für die Kubernetes bekannt ist. Wenn du Anwendungen in Kubernetes bereitstellst, werden diese in einem Cluster bereitgestellt. Zu den Hauptkomponenten des Clusters gehören eine Steuerungsebene (die globale Entscheidungen über den Cluster trifft) und die Worker Nodes (auf denen die Anwendungen tatsächlich laufen).

Kubernetes einrichten

Kubernetes installieren

Zu den ersten Schritten mit Kubernetes gehört die Einrichtung der Umgebung. Du kannst Kubernetes auf verschiedenen Plattformen installieren, einschließlich lokaler Maschinen, Cloud-Diensten wie unseren VPS, VDS oder Dedicated Servern sowie in hybriden Systemen.

Für ein lokales Setup sind Tools wie Minikube oder Kind beliebt, da sie eine einfache Möglichkeit bieten, einen Kubernetes-Cluster auf dem eigenen Rechner zu erstellen. Für Cloud-basierte Lösungen bieten die meisten großen Anbieter verwaltete Kubernetes-Dienste an (wie GKE von Google, EKS von Amazon oder AKS von Microsoft), die die Erstellung und Verwaltung von Clustern vereinfachen.

Der Installationsprozess umfasst im Allgemeinen folgende Schritte:

1. Einrichtung einer Maschine (physisch oder virtuell), die die Systemanforderungen von Kubernetes erfüllt.
2. Installation einer Container-Laufzeitumgebung wie zum Beispiel Docker. (Lies dazu unseren Guide: „Wie man Docker mit Cloud-Init installiert“)
3. Die Installation von Kubernetes selbst, welche die Einrichtung der Steuerungsebene und der Worker-Knoten umfasst.
4. Konfiguration der Netzwerkeinstellungen, um die Kommunikation zwischen der Steuerungsebene und den Worker-Knoten zu ermöglichen.

Für eine erfolgreiche Installation ist es wichtig, der spezifischen Installationsanleitung für die von dir gewählte Plattform zu folgen.

Überblick über die wichtigsten Komponenten

Sobald Kubernetes installiert ist, ist es wichtig, seine Schlüsselkomponenten zu verstehen. Diese arbeiten zusammen, um den Zustand deines Clusters zu verwalten und deine Anwendungen auszuführen.

• Steuerungsebene (Control Plane): Sie ist verantwortlich für globale Entscheidungen über den Cluster, wie z. B. die Planung von Anwendungen sowie die Erkennung von und Reaktion auf Cluster-Ereignisse. Zu ihren Schlüsselelementen gehören der kube-api-server, etcd (ein Key-Value-Speicher für alle Cluster-Daten), der scheduler und der controller-manager.
• Worker Nodes: Dies sind die Maschinen, die deine Anwendungen und Workloads ausführen. Jeder Node hat ein kubelet (ein Agent zur Verwaltung des Nodes) und eine Container-Laufzeitumgebung.
• Pods: Die kleinste bereitstellbare Einheit in Kubernetes. Ein Pod repräsentiert eine einzelne Instanz einer Anwendung und enthält einen oder mehrere Container.
• Services und Ingress: Diese Komponenten bieten Mechanismen, um deine Anwendungen innerhalb und außerhalb des Clusters verfügbar zu machen und die Kommunikation zu steuern.
• Speicher (Storage): Konzepte wie Volumes und PersistentVolumes ermöglichen es, Daten dauerhaft zu speichern und zustandsbehaftete Anwendungen zu betreiben.
• ConfigMaps und Secrets: Damit verwaltest du Konfigurationsdaten und sensible Informationen (wie Passwörter oder API-Schlüssel) für deine Anwendungen.

Anwendungen bereitstellen

In diesem Kapitel befassen wir uns mit den praktischen Aspekten der Bereitstellung und Verwaltung von Anwendungen in Kubernetes.

Pods erstellen und verwalten

Die Bereitstellung von Anwendungen in Kubernetes beginnt mit Pods.

Pods erstellen:

Definiere einen Pod: Dies geschieht mittels einer YAML- oder JSON-Datei, dem sogenannten Manifest. Das Manifest beschreibt den Inhalt des Pods, wie das zu verwendende Container-Image, Ports und Speicher-Volumes.Hier ist ein Beispiel für eine Pod-Konfiguration, die einen Apache-Webserver ausführt:

apiVersion: v1 

kind: Pod 

metadata: 

  name: apache-pod 

  labels: 

    purpose: serve-web 

spec: 

  containers: 

  - name: apache-container 

    image: httpd 

    ports: 

    - containerPort: 80

Pod bereitstellen: Verwende den Befehl kubectl apply mit der Manifest-Datei, um den Pod in deinem Cluster zu erstellen.Für unseren Beispiel-Pod würde der Befehl lauten:

kubectl apply -f apache-pod.yaml

Pods verwalten:

• Überwachung: Prüfe den Status der Pods mit kubectl get pods.
• Debugging und Logs: Benutze kubectl logs [POD_NAME], um die Protokolle eines Pods einzusehen, was für die Diagnose von Problemen entscheidend ist.
• Pods löschen: Pods können mit kubectl delete pod [POD_NAME] entfernt werden.

Services: Verbinden und Skalieren

Services in Kubernetes sind eine abstrakte Methode, um eine Anwendung, die auf einer Gruppe von Pods läuft, als Netzwerkdienst verfügbar zu machen. Sie bieten eine stabile Adresse, um auf die Pods zuzugreifen, selbst wenn diese neu gestartet werden und ihre IP-Adressen ändern.

Services erstellen:

Wie Pods werden auch Services in einer YAML-Datei definiert. Die Service-Definition enthält Selektoren, um die zugehörigen Pods zu bestimmen, sowie die Ports, die freigegeben werden sollen. Der Dienst wird ebenfalls mit kubectl apply erstellt.

Arten von Services:

• ClusterIP (Standard): Macht den Service nur über eine interne IP-Adresse innerhalb des Clusters erreichbar.
• NodePort: Macht den Service auf der IP-Adresse jedes Nodes an einem festen, statischen Port verfügbar. Dies ermöglicht externen Zugriff.
• LoadBalancer: Integriert sich mit Cloud-basierten Load Balancern, um den Service extern bereitzustellen. Dies wird häufig in Cloud-Umgebungen verwendet.

Anwendungen skalieren:

• Horizontale Pod-Autoskalierung: Erhöht oder verringert automatisch die Anzahl der Pod-Replikate basierend auf der CPU-Auslastung oder anderen Metriken.
• ReplicaSets und Deployments: Verwalten die Bereitstellung und Skalierung von Pods und ermöglichen deklarative Updates für Anwendungen.

Nachdem du nun die Grundlagen von Kubernetes kennst, werde mit unserem nächsten Guide in dieser Reihe zum Kubernetes-Profi: „Mastering Kubernetes“.