Kubernetes (eBook)

Einleitung

Kubernetes möchte jedem Sysadmin danken, der um 3 Uhr in der Früh geweckt wurde, um einen Prozess neu zu starten. Jedem Entwickler, der Code in die Produktivumgebung geschoben hat, um dann festzustellen, dass er dort nicht wie auf dem eigenen Laptop lief. Jedem Systemarchitekten, der unabsichtlich einen Lasttest gegen den Produktivserver laufen ließ, weil irgendein Hostname nicht angepasst wurde. Dieser Schmerz, diese unfreundlichen Arbeitszeiten und diese verrückten Fehler haben die Entwicklung von Kubernetes inspiriert. Kurz: Kubernetes will das Bauen, Deployen und Warten verteilter Systeme radikal vereinfachen. Es wurde durch die jahrzehntelange Erfahrung beim Bauen zuverlässiger Systeme inspiriert und ist von Grund auf so entworfen, dass sein Einsatz vielleicht nicht euphorisch macht, aber zumindest erfreut. Wir hoffen, Sie haben an diesem Buch Spaß!

Wer dieses Buch lesen sollte

Ob Sie mit verteilten Systemen noch keine Erfahrung haben oder schon seit Jahren Cloud-native Systeme deployen – Container und Kubernetes können Ihnen dabei helfen, in Bezug auf Geschwindigkeit, Agilität, Zuverlässigkeit und Effizienz in ganz neue Bereiche vorzustoßen. Dieses Buch beschreibt den Cluster-Orchestrierer Kubernetes und die Anwendung seiner Tools und APIs, um die Entwicklung, Auslieferung, Sicherheit und Wartung verteilter Anwendungen zu verbessern. Es wird zwar keine Erfahrung mit Kubernetes vorausgesetzt, aber um den größtmöglichen Nutzen aus diesem Buch zu ziehen, sollten Sie mit dem Bauen und Deployen von serverbasierten Anwendungen vertraut sein. Wenn Sie Konzepte wie Load Balancer und Network Storage kennen, ist das nützlich, aber nicht zwingend erforderlich. Genauso ist Erfahrung mit Linux, Linux-Containern und Docker zwar nicht essenziell, aber sie hilft Ihnen, um das Buch möglichst gut einsetzen zu können.

Warum wir dieses Buch geschrieben haben

Wir haben mit Kubernetes seit seinen Anfängen zu tun. Es war wirklich erstaunlich, seine Entwicklung von einer Spielerei, die vor allem experimentell genutzt wurde, hin zu einer zentralen, produktionsreifen Infrastruktur zu beobachten, die produktive Anwendung im großen Maßstab in vielen Bereichen betreibt. Auf diesem Weg wurde immer deutlicher, dass ein Buch mit den zentralen Konzepten von Kubernetes und der Motivation hinter der Entwicklung dieser Konzepte für die aktuelle Cloud-native Anwendungsentwicklung ein wichtiger Beitrag wäre. Wir hoffen, dass Sie mit dem Lesen dieses Buches nicht nur lernen, wie Sie zuverlässige und skalierbare Anwendungen auf Basis von Kubernetes bauen, sondern auch Einblicke in die zentralen Herausforderungen verteilter Systeme erlangen, die zu dessen Entwicklung geführt haben.

Warum wir dieses Buch aktualisiert haben

In den Jahren seit dem Erscheinen der ersten und zweiten Auflage dieses Buches ist das Ökosystem von Kubernetes weiter gewachsen und hat sich fortentwickelt. Es gab viele Releases von Kubernetes, und viele zusätzliche Tools und Patterns für den Einsatz von Kubernetes wurden zu De-facto-Standards. In der dritten Auflage haben wir uns darauf konzentriert, Themen hinzuzunehmen, die im Ökosystem von Kubernetes wachsendes Interesse verzeichnen, wie zum Beispiel Sicherheit, den Zugriff über Programmiersprachen und das Deployen in mehrere Cluster. Auch haben wir die bestehenden Kapitel auf den neuesten Stand gebracht, um die Änderungen und die Weiterentwicklung von Kubernetes widerzuspiegeln. Wir gehen fest davon aus, dieses Buch in ein paar Jahren erneut überarbeiten zu müssen (und freuen uns darauf), wenn Kubernetes weiter seinen Weg geht.

Ein Wort zu aktuellen Cloud-nativen Anwendungen

Von den ersten Programmiersprachen über die objektorientierte Programmierung bis hin zur Entwicklung der Virtualisierung und Cloud-Infrastruktur ist die Geschichte der Informatik auch eine Geschichte der Entwicklung von Abstraktionen, die Komplexität verbergen und Sie in die Lage versetzen, immer ausgefeiltere Anwendungen zu bauen. Trotzdem ist das Entwickeln zuverlässiger, skalierbarer Anwendungen immer noch eine viel größere Herausforderung, als es sein sollte. In den letzten Jahren hat sich gezeigt, dass Container und zugehörige Orchestrierungs-APIs wie Kubernetes zu einer wichtigen Abstraktion wurden, die die Entwicklung zuverlässiger, skalierbarer und verteilter Systeme radikal vereinfacht hat. Container und Orchestrierer ermöglichen es Entwicklern, Anwendungen mit einer Schnelligkeit, Agilität und Zuverlässigkeit zu bauen, die vor ein paar Jahren noch als unerreichbare Zukunftsmusik gegolten hätten.

Was Sie in diesem Buch finden

Dieses Buch ist wie folgt organisiert. Kapitel 1 umreißt auf allgemeinem Niveau die Vorteile von Kubernetes, ohne allzu sehr in die Details zu gehen. Wenn Kubernetes für Sie neu ist, hilft Ihnen dieses Kapitel, zu verstehen, warum Sie den Rest des Buches lesen sollten.

Kapitel 2 liefert eine detaillierte Einführung in Container und die containerisierte Anwendungsentwicklung. Wenn Sie noch nie mit Docker gespielt haben, wird dieses Kapitel eine nützliche Einführung sein. Sind Sie schon ein Docker-Experte, wird es sich für Sie eher um ein Review handeln.

Kapitel 3 behandelt das Deployen von Kubernetes. Während sich ein Großteil dieses Buches darum dreht, wie Sie Kubernetes einsetzen, brauchen Sie ein lauffähiges Cluster, bevor Sie loslegen können. Das Betreiben eines Clusters für eine Produktiv-Umgebung liegt außerhalb des Rahmens dieses Buches, aber in diesem Kapitel stellen wir ein paar einfache Wege vor, ein Cluster so aufzusetzen, dass Sie verstehen können, wie Sie Kubernetes einsetzen. Kapitel 4 beschreibt eine Auswahl von gebräuchlichen Befehlen, die zur Interaktion mit Kubernetes-Clustern eingesetzt werden.

Ab Kapitel 5 kümmern wir uns um die Details des Deployens einer Anwendung mit Kubernetes. Wir beschreiben Pods (Kap. 5), Labels und Anmerkungen (Kap. 6), Services (Kap. 7), Ingress (Kap. 8) und ReplicaSets (Kap. 9). Diese bilden die Grundlagen für das Deployen Ihres Service in Kubernetes. Dann wenden wir uns Deployments zu (Kap. 10), die den Lebenszyklus einer kompletten Anwendung verbinden.

Im Anschluss daran geht es um speziellere Objekte in Kubernetes: DaemonSets (Kap. 11), Jobs (Kap. 12) sowie ConfigMaps und Secrets (Kap. 13). Diese Kapitel sind zwar für viele produktive Anwendungen wichtig, aber wenn Sie Kubernetes gerade erst kennenlernen, können Sie sie überspringen und sich später mit ihnen beschäftigen, wenn Sie mehr Erfahrung und Expertise erlangt haben.

In Kapitel 14 stellen wir dann die Role-Based Access Control (RBAC) vor und kümmern uns um Service Meshes (Kap. 15) und das Integrieren von Storage in Kubernetes (Kap. 16). Wir beschreiben das Erweitern von Kubernetes (Kap. 17) und den Zugriff über Programmiersprachen (Kap. 18). Dann geht es um das Absichern von Pods (Kap. 19) und Policy und Governance in Kubernetes (Kap. 20). Zum Schluss stellen wir noch Beispiele für das Entwickeln und Deployen von Multicluster-Anwendungen (Kap. 21) vor und wir beschreiben, wie Sie Ihre Anwendungen unter Versionskontrolle organisieren können (Kap. 22).

Online-Ressourcen

Sie sollten Docker (https://docker.com) installieren. Auch werden Sie sich mit der zugehörigen Dokumentation vertraut machen wollen, wenn Sie das noch nicht getan haben.

Genauso sollten Sie das Befehlszeilen-Tool kubectl (https://kubernetes.io) installieren und dem Slack-Channel Kubernetes beitreten (https://slack.kubernetes.io), wo Sie eine große Community vorfinden, die nahezu rund um die Uhr zum Reden und Beantworten von Fragen bereitsteht.

Wenn Sie schließlich mehr Erfahrung gesammelt haben, können Sie sich auch mit dem Open-Source-Repository von Kubernetes auf GitHub vertraut machen (https://github.com/kubernetes/kubernetes).

Konventionen in diesem Buch

Die folgenden typografischen Konventionen werden in diesem Buch genutzt:

• Kursiv
  Für neue Begriffe, URLs, E-Mail-Adressen, Dateinamen und Dateierweiterungen.
• Nichtproportionalschrift
  Für Programmlistings, aber auch für Codefragmente in Absätzen, wie etwa Variablen- oder Funktionsnamen, Datenbanken, Datentypen, Umgebungsvariablen, Anweisungen und Schlüsselwörter.
• fette Nichtproportionalschrift
  Für Befehle und anderen Text, der genau so vom Benutzer eingegeben werden sollte.
• kursive Nichtproportionalschrift
  Für Text, der vom Benutzer durch eigene Werte ersetzt werden sollte.