Was ist Kubernetes (K8s)? Ein Tutorial zu den Grundlagen von Kubernetes

In diesem Beitrag werden wir Kubernetes, auch bekannt als K8s, erklären . In dieser Einführung behandeln wir:

• Was Kubernetes ist
• Was es nicht kann
• Die Probleme, die es löst
• K8s-Architekturkomponenten
• Installation
• Alternative Optionen

Dieser Artikel setzt voraus, dass du neu bei Kubernetes bist und ein solides Verständnis der Konzepte und Bausteine erlangen möchtest.

Was ist Kubernetes?

Um den Nutzen von Kubernetes zu verstehen, müssen wir zunächst zwei Konzepte verstehen: unveränderliche Infrastruktur und Container.

• Unveränderliche Infrastruktur ist eine Praxis, bei der Server nach der Bereitstellung nie verändert werden. Wenn etwas geändert werden muss, geschieht das nie direkt auf dem Server. Stattdessen baut man einen neuen Server aus einem Basis-Image, in dem alle benötigten Änderungen integriert sind. So können wir einfach den alten Server durch den neuen ersetzen, ohne weitere Änderungen.
• Container bieten eine Möglichkeit, Code, Laufzeit, Systemwerkzeuge, Systembibliotheken und Konfigurationen insgesamt zu paketieren. Diese Lieferung ist eine leichte, eigenständige ausführbare Datei. So verhält sich Ihre Anwendung jedes Mal gleich, egal wo sie läuft (z. B. Ubuntu, Windows usw.). Containerisierung ist kein neues Konzept, hat aber mit dem Aufkommen von Microservices und Docker enorm an Popularität gewonnen.

Mit diesen Konzepten können wir Kubernetes nun als Container- oder Microservice-Plattform definieren , die Rechen-, Netzwerk- und Speicherinfrastruktur-Workloads orchestriert. Da es die Arten von Anwendungen, die man bereitstellen kann (jede Sprache funktioniert), nicht einschränkt, erweitert Kubernetes die Skalierung containerisierter Anwendungen, sodass wir alle Vorteile einer wirklich unveränderlichen Infrastruktur genießen können. Die allgemeine Faustregel für K8S: Wenn Ihre App in einen Container passt, wird Kubernetes sie bereitstellen. Übrigens, falls Sie sich fragen, woher der Name "Kubernetes" stammt: Es ist ein griechisches Wort, das Steuermann oder Pilot bedeutet  . Die Abkürzung K8s wird dadurch abgeleitet, dass die acht Buchstaben von "ubernete" durch die Ziffer 8 ersetzt werden. Das Kubernetes-Projekt wurde 2014 von Google als Open Source veröffentlicht, nachdem es über ein Jahrzehnt lang Produktionsworkloads im großen Maßstab ausgeführt hatte. Kubernetes ermöglicht dynamisch skalierende, containerisierte Anwendungen und die Nutzung einer API für das Management. Kubernetes ist ein herstellerunabhängiges Containermanagement-Tool, das Cloud-Computing-Kosten minimiert und gleichzeitig den Betrieb widerstandsfähiger und skalierbarer Anwendungen vereinfacht. Kubernetes ist zum Standard für containerisierte Anwendungen in der Cloud geworden, wobei die wichtigsten Cloud-Anbieter (AWS, Azure, GCE, IBM und Oracle) nun Managed Kubernetes-Dienste anbieten.

Grundlegende Begriffe und Definitionen von Kubernetes

Um zu verstehen, wie man K8S verwendet, müssen wir die Objekte in der API verstehen. Grundlegende K8S-Objekte und mehrere höherstufige Abstraktionen werden als Controller bezeichnet . Diese sind der Baustein Ihres Anwendungslebenszyklus. Grundlegende Objekte umfassen:

• Kapsel. Eine Gruppe von einem oder mehreren Behältern.
• Service. Eine Abstraktion, die eine logische Menge von Pods sowie die Richtlinie zum Zugriff darauf definiert.
• Volumen. Eine Abstraktion, die es uns erlaubt, Daten zu speichern. (Das ist notwendig, weil Container flüchtig sind – das heißt, Daten werden gelöscht, wenn der Container gelöscht wird.)
• Namespace. Ein Abschnitt des Clusters, der einem bestimmten Zweck gewidmet ist, zum Beispiel einem bestimmten Projekt oder Team von Entwicklern.

Controller oder höherstufige Abstraktionen umfassen:

• ReplicaSet (RS). Stellt sicher, dass die gewünschte Menge an Pod läuft.
• Deployment. Bietet deklarative Updates für Pods und RS.
• StatefulSet. Ein Workload-API-Objekt, das zustandsbehaftete Anwendungen wie Datenbanken verwaltet.
• DaemonSet. Stellt sicher, dass alle oder einige Worker-Knoten eine Kopie eines Pods ausführen. Dies ist nützlich für Daemon-Anwendungen wie Fluentd.
• Job. Erstellt einen oder mehrere Pods, führt eine bestimmte Aufgabe bis zum Abschluss aus und löscht dann die Pods.

Mikroservice

Ein spezifischer Teil einer zuvor monolithischen Anwendung. Eine traditionelle microservicebasierte Architektur hätte mehrere Services, die ein oder mehrere Endprodukte ausmachen. Microservices werden typischerweise zwischen Anwendungen geteilt und erleichtern die Verwaltung von Continuous Integration und Continuous Delivery. Erkunden Sie den Unterschied zwischen monolithischer und Microservices-Architektur.

Bilder

Typischerweise ein Docker-Container-Image – ein ausführbares Image, das alles enthält, was Sie zum Ausführen Ihrer Anwendung benötigen; Anwendungscode, Bibliotheken, eine Laufzeit, Umgebungsvariablen und Konfigurationsdateien. Zur Laufzeit wird ein Container-Image zu einem Container, der alles ausführt, was in dieses Image gepackt wird.

Pods

Eine einzelne oder mehrere Container, die Speicher und Netzwerk mit einer Kubernetes-Konfiguration teilen und diesen Containern vorweisen, wie sie sich verhalten sollen. Pods teilen sich IP- und Portadressraum und können über Localhost-Netzwerke miteinander kommunizieren. Jeder Pod erhält eine IP-Adresse, auf die andere Pods innerhalb eines Clusters zugreifen können. Anwendungen innerhalb eines Pods haben Zugriff auf gemeinsame Volumes – hilfreich, wenn Daten über die Lebensdauer eines Pods hinaus erhalten bleiben müssen. Erfahren Sie mehr über Kubernetes-Pods.

Namensräume

Namensräume sind eine Möglichkeit, mehrere virtuelle Kubernetes-Cluster innerhalb eines einzigen Clusters zu erstellen. Namensräume werden normalerweise für groß angelegte Deployments verwendet, bei denen viele Nutzer, Teams und Projekte vorhanden sind.

Replika-Set

Ein Kubernetes-Replica-Set stellt sicher, dass die angegebene Anzahl der Pods in einem Replica-Set jederzeit läuft. Wenn ein Pod ausfällt oder abstürzt, sorgt die Konfiguration dafür, dass an seiner Stelle ein neuer erstellt wird. Normalerweise würde man eine Deployment verwenden, um dies anstelle eines Replica Set zu verwalten. Erfahren Sie mehr über Kubernetes ReplicaSets.

Einsätze

Eine Möglichkeit, den gewünschten Zustand von Pods oder einem Replica-Set zu definieren. Deployments werden verwendet, um HA-Richtlinien für Ihre Container zu definieren, indem Richtlinien festgelegt werden, wie viele von jedem Container gleichzeitig laufen müssen.

Dienstleistungen

Koppelung einer Gruppe von Pods an eine Richtlinie zum Zugriff darauf. Dienste werden verwendet, um containerisierte Anwendungen außerhalb des Clusters auf Ursprünge zu bringen. Erfahren Sie mehr über Kubernetes-Dienste.

Knoten

Ein (normalerweise) virtueller Host(s), auf dem Container/Pods ausgeführt werden.

Kubernetes-Architektur und Komponenten

Ein K8S-Cluster besteht aus einem Master-Knoten, der die API bereitstellt, Bereitstellungen plant und den Cluster allgemein verwaltet. Mehrere Worker-Knoten können für die Containerlaufzeit verantwortlich sein, wie Docker oder rkt, zusammen mit einem Agenten, der mit dem Master kommuniziert.

Masterkomponenten

Diese Masterkomponenten bilden einen Master-Knoten:

• Kube-apiserver. Stellt die API frei.
• Etcd. Der Schlüsselwert speichert alle Clusterdaten. (Kann auf demselben Server wie ein Master-Node oder auf einem dedizierten Cluster ausgeführt werden.)
• Kube-Scheduler. Plant neue Pods auf Worker-Nodes.
• Kube-Controller-Manager. Bedient die Controller.
• Cloud-Controller-Manager. Spricht mit Cloud-Anbietern.

Knotenkomponenten

• Kubelet. Agent, der sicherstellt, dass Container in einer Kapsel laufen.
• Kube-Proxy. Behält Netzwerkregeln und führt Weiterleitung durch.
• Containerlaufzeit. Führt Container aus.

Welche Vorteile bietet Kubernetes?

Direkt aus der Verpackung bietet K8S mehrere Schlüsselfunktionen, die es uns ermöglichen, unveränderliche Infrastruktur zu betreiben. Container können automatisch gelöscht, ersetzt und sich selbst heilen, und der neue Container erhält Zugriff auf diese Support-Volumes , Geheimnisse, Konfigurationen usw., die ihn funktionieren lassen. Diese wichtigen K8S-Funktionen sorgen dafür, dass Ihre containerisierte Anwendung effizient skaliert:

• Horizontale Skalierung. Skaliere deine Anwendung nach Bedarf über die Kommandozeile oder die Benutzeroberfläche.
• Automatisierte Rollouts und Rollbacks. Implementieren Sie Änderungen, die den Zustand Ihrer Anwendung überwachen – und sicherstellen, dass nicht alle Instanzen gleichzeitig ausfallen oder ausfallen. Wenn etwas schiefgeht, setzt K8S die Änderung automatisch zurück.
• Service-Entdeckung und Lastverteilung. Container erhalten ihre eigene IP-Adresse, sodass man eine Reihe von Containern hinter einen einzigen DNS-Namen für die Lastverteilung legen kann.
• Speicherorchestrierung. Automatische lokale oder öffentliche Cloud oder einen Netzwerkspeicher einbauen.
• Secret- und Konfigurationsmanagement. Erstellen und aktualisieren Sie Geheimnisse und Konfigurationen , ohne Ihr Image neu zusammenzustellen.
• Selbstheilend. Die Plattform heilt viele Probleme: fehlgeschlagene Container neu starten, Container ersetzen und neu planen, wenn Knoten sterben, Container abschalten, die nicht auf deine benutzerdefinierte Gesundheitsprüfung reagieren, und warten darauf, Container den Kunden zu bewerben, bis sie bereit sind.
• Batch-Ausführung. Verwalten Sie Ihre Batch- und Continuous Integration-Workloads und ersetzen Sie ausgefallene Container.
• Automatisches Binpacking. Plant Container automatisch basierend auf Ressourcenbedarf und anderen Einschränkungen.

Was macht Kubernetes nicht?

Kubernetes kann viele coole und nützliche Dinge tun. Aber genauso wichtig ist es zu bedenken, was Kubernetes nicht kann:

• Es ersetzt keine Werkzeuge wie Jenkins – also wird es Ihre Anwendung nicht für Sie erstellen.
• Es ist keine Middleware – sie führt also keine Aufgaben aus, die eine Middleware erledigt, wie zum Beispiel Nachrichtenbus oder Caching, um nur einige zu nennen.
• Es ist egal, welche Logging-Lösung verwendet wird. Lass deine App bei stdout protokollieren, dann kannst du die Logs mit allem sammeln, was du möchtest.
• Es interessiert sich nicht für deine Konfigurationssprache (z. B. JSON).

K8s ist bei diesen Dingen nicht meinungsstark, nur um uns zu erlauben, unsere App so zu entwickeln, wie wir wollen, jegliche Art von Informationen offenzulegen und diese zu sammeln, wie wir wollen.

Kubernetes-Konkurrenten

Natürlich ist Kubernetes nicht das einzige Tool auf dem Markt. Es gibt eine Vielzahl davon, darunter:

• Docker Compose – gut zum Staging, aber nicht produktionsbereit.
• Nomad – ermöglicht Cluster-Management und -Planung, löst aber nicht die Secret- und Konfigurationsverwaltung, Service-Entdeckung und Überwachung.
• Titus – Netflix' Open-Source-Orchestrierungsplattform nutzt nicht genug Leute in der Produktion.

Insgesamt bietet Kubernetes die besten direkten Funktionen sowie unzählige Drittanbieter-Add-ons, um seine Funktionalität einfach zu erweitern.

Einstieg mit Kubernetes

Typischerweise installiert man Kubernetes entweder auf On-Premise-Hardware oder einem der großen Cloud-Anbieter. Viele Cloud-Anbieter und Drittanbieter bieten inzwischen Managed Kubernetes-Dienste an, aber für eine Test-/Lernerfahrung ist das sowohl kostspielig als auch nicht zwingend erforderlich. Der einfachste und schnellste Weg, mit Kubernetes in einer isolierten Entwicklungs-/Testumgebung zu beginnen, ist Minikube.

Wie man Kubernetes installiert

Die lokale Installation von K8S ist einfach und unkompliziert. Man braucht zwei Dinge, um es zum Laufen zu bringen: Kubectl und Minikube.

• Kubectl ist ein CLI-Tool, das es ermöglicht, mit dem Cluster zu interagieren.
• Minikube ist eine Binär, die einen Cluster lokal auf deiner Entwicklungsmaschine bereitstellt.

Damit können Sie Ihre containerisierten Apps innerhalb weniger Minuten lokal in einem Cluster bereitstellen. Für einen hochverfügbaren produktionsfähigen Cluster können Sie Tools wie folgende verwenden:

• Kops
• EKS, ein von AWS verwalteter Dienst
• GKE, bereitgestellt von Google

Minikube ermöglicht es dir, einen Einzelknoten-Cluster innerhalb einer virtuellen Maschine (typischerweise innerhalb von VirtaulBox) auszuführen. Folge der offiziellen Kubernetes-Dokumentation, um Minikube auf deinem Rechner zu installieren. https://kubernetes.io/docs/setup/minikube/. Mit Minikube installiert bist du jetzt bereit, einen virtualisierten Einzelknoten-Cluster auf deinem lokalen Rechner zu betreiben. Du kannst deinen Minikube-Cluster starten mit:

Die Interaktion mit Kubernetes-Clustern erfolgt meist über die kubectl CLI oder das Kubernetes Dashboard. Die kubectl CLI unterstützt außerdem Bash Autocompletion und spart viel Tippen (und Speicher). Installiere die kubectl CLI auf deinem Rechner, indem du die offiziellen Installationsanweisungen https://kubernetes.io/docs/tasks/tools/install-kubectl/. Um mit deinen Kubernetes-Clustern zu interagieren, musst du deinen kubectl CLI-Kontext festlegen. Ein Kubernetes-Kontext ist eine Gruppe von Zugriffsparametern, die definieren, welche Benutzer Zugriff auf Namensräume innerhalb eines Clusters haben. Beim Start von Minikube wird der Kontext standardmäßig automatisch auf minikube umgestellt. Es gibt eine Reihe von kubectl CLI-Befehlen, die definieren, gegen welchen Kubernetes-Cluster die Befehle ausgeführt werden.

Bereitstellung Ihrer ersten containerisierten Anwendung bei Minikube

Bisher solltest du einen lokalen Single-Node-Kubernetes-Cluster auf deinem lokalen Rechner laufen lassen. Der Rest dieses Tutorials wird die Schritte erläutern, die nötig sind, um eine einfache Hello World-Containeranwendung in einem Pod mit einem offenen Endpunkt auf der IP-Adresse des Minikube-Knotens bereitzustellen. Erstelle die Kubernetes-Bereitstellung mit:

Wir können sehen, dass unsere Bereitstellung erfolgreich war, sodass wir die Bereitstellung mit:

Unsere Bereitstellung hätte einen Kubernetes-Pod erstellen sollen. Wir können die Pods in unserem Cluster anzeigen mit:

Bevor wir unsere Hello World-Anwendung mit einer HTTP-Anfrage von einem Ursprung außerhalb unseres Clusters (also unserer Entwicklungsmaschine) erreichen können, müssen wir den Pod als Kubernetes-Dienst offenstellen. Standardmäßig sind Pods nur auf ihrer internen IP-Adresse zugänglich, die von außerhalb des Clusters keinen Zugriff hat.

Das Offenlegen einer Bereitstellung erzeugt einen Kubernetes-Service. Wir können den Service anzeigen mit:

Bei der Nutzung eines Cloud-Anbieters würde man normalerweise —type=loadbalancer so einstellen, dass der Dienst entweder einer privaten oder öffentlichen IP-Adresse außerhalb des ClusterIP-Bereichs zugewiesen wird. Minikube unterstützt keine Load Balancer, da es sich um eine lokale Entwicklungs-/Testumgebung handelt, und daher verwendet —type=NodePort die Minikube-Host-IP für den Service-Endpunkt. Um die URL zu ermitteln, mit der auf den containerisierten Anwendungstyp zugegriffen wird;

Lenken Sie die Antwort von Ihrem Terminal, um zu testen, ob unser exponierter Dienst unseren Pod erreicht.

Jetzt haben wir eine HTTP-Anfrage an unseren Pod über den Kubernetes-Dienst gestellt, wir können bestätigen, dass alles wie erwartet funktioniert. Wenn wir die Pod-Logs überprüfen, sollten wir unsere HTTP-Anfrage sehen.

Abschließend betreiben wir nun eine einfache containerisierte Anwendung in einem Kubernetes-Cluster mit einem einzelnen Knoten, mit einem offenen Endpunkt über einen Kubernetes-Service.

Minikube zum Lernen

Minikube eignet sich hervorragend, um sich mit Kubernetes vertraut zu machen und die Konzepte der Container-Orchestrierung in großem Maßstab zu lernen, aber du möchtest deine Produktions-Workloads nicht von deinem lokalen Rechner ausführen. Nach dem oben Genannten solltest du jetzt einen funktionierenden Kubernetes-Pod, Service und Deployment haben, der eine einfache Hello World-Anwendung ausführt. Wenn du von hier aus Kubernetes für deine containerisierten Anwendungen nutzen möchtest, bist du am besten geeignet, einen Kubernetes-Cluster zu bauen oder die vielen Managed Kubernetes-Angebote der beliebten Cloud-Anbieter zu vergleichen.

Zusätzliche Ressourcen

Für mehr Informationen zu Kubernetes entdecken Sie diese Ressourcen:

• Kubernetes-Leitfaden mit 20+ Artikeln und Tutorials
• BMC DevOps Blog

Kubernetes-Leitfaden

1. Was ist Kubernetes (K8s)? Ein Tutorial zu den Grundlagen von Kubernetes
2. Kubernetes Best Practices für verbesserte Cluster-Effizienz
3. Best Practices: Wie man Anwendungen für Kubernetes architekt
4. Kubernetes Pods: Eine Einführung
5. Kubernetes ReplicaSets: Eine kurze Einführung
6. Kubernetes-Deployments vollständig erklärt
7. Wie man Kubernetes DaemonSets verwendet und verwaltet
8. Wie Kubernetes-Dienste funktionieren
9. Verwendung von Kubernetes Port, TargetPort und NodePort
10. Erstellen und verwenden von ConfigMaps in Kubernetes
11. Einführung in Kubernetes-Geheimnisse
12. Kubernetes-Netzwerkgrundlagen
13. Kubernetes-Ingress erklärt
14. Einführung in Kubernetes Helm Charts
15. Was ist das Kubernetes-Operator-Muster?
16. Bereitstellung von PostgreSQL als StatefulSet in Kubernetes
17. Kubernetes Custom Resource Definition (CRDs) erklärt
18. 3 Kubernetes-Muster für Cloud-native Anwendungen
19. Kubernetes Compute-Ressourcen erklärt
20. Kubernetes-Sicherheit für DevOps-Pipelines
21. Verwendung von Spinnaker mit Kubernetes für Continuous Delivery
22. Kubernetes-Multi-Cluster: Wie und warum man sie verwendet.
23. Kubernetes-Überwachung: Ein umfassender Leitfaden
24. Kubernetes vs. Docker: Ein kurzer Vergleich
25. Kubernetes vs. Docker Swarm: Vergleich von Container-Orchestrierungstools
26. Kubernetes vs. OpenShift: Was ist der Unterschied?
27. Kubernetes-Zertifizierungen: Wie und warum man zertifiziert wird

Diese Beiträge sind meine eigenen und spiegeln nicht unbedingt die Position, Strategien oder Meinung von BMC wider.