Kubernetes in Action

Inhalt

Vorwort

Der Autor

Danksagung zur englischsprachigen Ausgabe

Über dieses Buch

Zielgruppe

Der Aufbau dieses Buches

Der Code

Das Forum zum Buch

Sonstige Onlinequellen

Teil I: Überblick

1 Einführung in Kubernetes

1.1 Der Bedarf für ein System wie Kubernetes

1.1.1 Von monolithischen Anwendungen zu Microservices

1.1.2 Eine konsistente Umgebung für Anwendungen bereitstellen

1.1.3 Übergang zu Continuous Delivery: DevOps und NoOps

1.2 Containertechnologien

1.2.1 Was sind Container?

1.2.2 Die Containerplattform Docker

1.2.3 Die Docker-Alternative rkt

1.3 Kubernetes

1.3.1 Die Ursprünge

1.3.2 Kubernetes im Überblick

1.3.3 Die Architektur eines Kubernetes-Clusters

1.3.4 Anwendungen auf Kubernetes ausführen

1.3.5 Vorteile der Verwendung von Kubernetes

1.4 Zusammenfassung

2 Erste Schritte mit Docker und Kubernetes

2.1 Containerimages mit Docker erstellen, ausführen und teilen

2.1.1 Docker installieren und einen Hello-world-Container ausführen

2.1.2 Eine triviale Node.js-Anwendung erstellen

2.1.3 Eine Docker-Datei für das Image erstellen

2.1.4 Das Containerimage erstellen

2.1.5 Das Containerimage ausführen

2.1.6 Das Innenleben eines laufenden Containers untersuchen

2.1.7 Container anhalten und entfernen

2.1.8 Das Image zu einer Registry hochladen

2.2 Kubernetes-Cluster einrichten

2.2.1 Einen lokalen Kubernetes-Cluster mit einem Knoten mithilfe von Minikube ausführen

2.2.2 Gehostete GKE-Cluster

2.2.3 Einen Alias und die Befehlszeilenvervollständigung für kubectl einrichten

2.3 Eine erste Anwendung in Kubernetes ausführen

2.3.1 Die Node.js-Anwendung bereitstellen

2.3.2 Auf die Webanwendung zugreifen

2.3.3 Die logischen Bestandteile des Systems

2.3.4 Anwendungen horizontal skalieren

2.3.5 Auf welchen Knoten läuft die Anwendung?

2.3.6 Das Kubernetes-Dashboard

2.4 Zusammenfassung

Teil II: Grundlagen

3 Pods: Container in Kubernetes ausführen

3.1 Einführung in Pods

3.1.1 Wozu benötigen wir Pods?

3.1.2 Grundlagen von Pods

3.1.3 Container auf Pods verteilen

3.2 Pods aus YAML- und JSON-Deskriptoren erstellen

3.2.1 Den YAML-Deskriptor eines bestehenden Pods untersuchen

3.2.2 Einen einfachen YAML-Deskriptor für einen Pod schreiben

3.2.3 Einen Pod mit kubectl create erstellen

3.2.4 Anwendungsprotokolle anzeigen

3.2.5 Anforderungen an den Pod senden

3.3 Pods mithilfe von Labels ordnen

3.3.1 Einführung in Labels

3.3.2 Labels beim Erstellen eines Pods angeben

3.3.3 Labels vorhandener Pods ändern

3.4 Eine Auswahl der Pods mithilfe von Labelselektoren auflisten

3.4.1 Pods anhand eines Labelselektors auflisten

3.4.2 Labelselektoren mit mehreren Bedingungen

3.5 Die Podzuweisung mithilfe von Labels und Selektoren einschränken

3.5.1 Labels zur Klassifizierung von Arbeitsknoten

3.5.2 Pods bestimmten Knoten zuweisen

3.5.3 Zuweisung zu einem einzelnen Knoten

3.6 Pods mit Anmerkungen versehen

3.6.1 Die Anmerkungen zu einem Objekt einsehen

3.6.2 Anmerkungen hinzufügen und ändern

3.7 Ressourcen mithilfe von Namespaces gruppieren

3.7.1 Der Bedarf für Namespaces

3.7.2 Andere Namespaces und die zugehörigen Pods finden

3.7.3 Namespaces erstellen

3.7.4 Objekte in anderen Namespaces verwalten

3.7.5 Die Trennung der Namespaces

3.8 Pods stoppen und entfernen

3.8.1 Pods unter Angabe des Namens löschen

3.8.2 Pods mithilfe von Labelselektoren löschen

3.8.3 Pods durch Entfernen eines ganzen Namespaces löschen

3.8.4 Alle Pods in einem Namespace löschen und den Namespace erhalten

3.8.5 (Fast) alle Ressourcen in einem Namespace löschen

3.9 Zusammenfassung

4 Replikationscontroller & Co.: Verwaltete Pods bereitstellen

4.1 Pods funktionsfähig halten

4.1.1 Aktivitätssonden

4.1.2 HTTP-Aktivitätssonden erstellen

4.1.3 Eine Aktivitätssonde in Aktion

4.1.4 Weitere Eigenschaften der Aktivitätssonde festlegen

4.1.5 Wirkungsvolle Aktivitätssonden erstellen

4.2 Replikationscontroller

4.2.1 Die Funktionsweise von Replikationscontrollern

4.2.2 Einen Replikationscontroller erstellen

4.2.3 Der Replikationscontroller in Aktion

4.2.4 Pods in den Gültigkeitsbereich eines Replikationscontrollers bringen und daraus entfernen

4.2.5 Das Pod-Template ändern

4.2.6 Pods horizontal skalieren

4.2.7 Einen Replikationscontroller löschen

4.3 Replikationssätze anstelle von Replikationscontrollern verwenden

4.3.1 Replikationssätze und Replikationscontroller im Vergleich

4.3.2 Einen Replikationssatz definieren

4.3.3 Einen Replikationssatz erstellen und untersuchen

4.3.4 Die ausdrucksstärkeren Labelselektoren des Replikationssatzes

4.3.5 Zusammenfassung: Replikationssätze

4.4 Daemonsets zur Ausführung einer Instanz eines Pods auf jedem Knoten

4.4.1 Einen Pod auf allen Knoten ausführen

4.4.2 Einen Pod nur auf einigen Knoten ausführen

4.5 Pods für endliche Aufgaben

4.5.1 Jobs

4.5.2 Einen Job definieren

4.5.3 Ein Job in Aktion

4.5.4 Mehrere Podinstanzen in einem Job ausführen

4.5.5 Die Zeit zum Abschließen eines Job-Pods begrenzen

4.6 Jobs regelmäßig oder zu einem späteren Zeitpunkt ausführen

4.6.1 Einen Cron-Job erstellen

4.6.2 Die Ausführung geplanter Jobs

4.7 Zusammenfassung

5 Dienste: Pods finden und mit ihnen kommunizieren

5.1 Dienste

5.1.1 Dienste erstellen

5.1.2 Dienste finden

5.2 Verbindungen zu Diensten außerhalb des Clusters

5.2.1 Dienstendpunkte

5.2.2 Manuell eingerichtete Dienstendpunkte

5.2.3 Einen Alias für einen externen Dienst erstellen

5.3 Dienste für externe Clients verfügbar machen

5.3.1 Einen NodePort-Dienst verwenden

5.3.2 Einen Dienst über einen externen Load Balancer verfügbar machen

5.3.3 Besondere Eigenschaften von externen Verbindungen

5.4 Dienste über eine Ingress-Ressource extern verfügbar machen

5.4.1 Eine Ingress-Ressource erstellen

5.4.2 Über den Ingress auf den Dienst zugreifen

5.4.3 Mehrere Dienste über denselben Domänennamen verfügbar machen

5.4.4 Einen Ingress für TLS-Datenverkehr einrichten

5.5 Die Bereitschaft eines Pods zur Annahme von Verbindungen signalisieren

5.5.1 Bereitschaftssonden

5.5.2 Einem Pod eine Bereitschaftssonde hinzufügen

5.5.3 Bereitschaftssonden in der Praxis

5.6 Headless-Dienste zur Ermittlung einzelner Pods

5.6.1 Einen headless-Dienst erstellen

5.6.2 Pods über DNS finden

5.6.3 Alle Pods finden – auch diejenigen, die nicht bereit sind

5.7 Fehlerbehebung bei Diensten

5.8 Zusammenfassung

6 Volumes: Festplattenspeicher zu Containern hinzufügen

6.1 Volumes

6.1.1 Ein Beispiel

6.1.2 Arten von Volumes

6.2 Gemeinsame Datennutzung durch die Container

6.2.1 emptyDir-Volumes

6.2.2 Ein Git-Repository als Ausgangspunkt für ein Volume verwenden

6.3 Zugriff auf Dateien im Dateisystem des Arbeitsknotens

6.3.1 HostPath-Volumes

6.3.2 Systempods mit hostPath-Volumes

6.4 Dauerhafte Speicherung

6.4.1 Eine GCE Persistent Disk in einem Pod-Volume

6.4.2 Andere Arten von Volumes mit zugrunde liegendem persistenten Speicher

6.5 Pods von der zugrunde liegenden Speichertechnologie entkoppeln

6.5.1 Persistente Volumes und Claims

6.5.2 Ein persistentes Volume erstellen

6.5.3 Mit einem Claim ein persistentes Volume beanspruchen

6.5.4 Einen Claim in einem Pod verwenden

6.5.5 Vorteile der Verwendung von persistenten Volumes und Claims

6.5.6 Persistente Volumes wiederverwenden

6.6 Persistente Volumes dynamisch bereitstellen

6.6.1 Die verfügbaren Speichertypen mit Speicherklassen definieren

6.6.2 Die Speicherklasse in einem Claim angeben

6.6.3 Dynamische Bereitstellung ohne Angabe einer Speicherklasse

6.7 Zusammenfassung

7 Konfigurationszuordnungen und Secrets: Anwendungen konfigurieren

7.1 Konfiguration von Anwendungen im Allgemeinen

7.2 Befehlszeilenargumente an Container übergeben

7.2.1 Den Befehl und die Argumente in Docker definieren

7.2.2 Den Befehl und die Argumente in Kubernetes überschreiben

7.3 Umgebungsvariablen für einen Container einrichten

7.3.1 Eine Umgebungsvariable in einer Containerdefinition festlegen

7.3.2 Im Wert einer Variablen auf andere Umgebungsvariablen verweisen

7.3.3 Die Nachteile hartkodierter Umgebungsvariablen

7.4 Die Konfiguration mit einer Konfigurationszuordnung entkoppeln

7.4.1 Einführung in Konfigurationszuordnungen

7.4.2 Eine Konfigurationszuordnung erstellen

7.4.3 Einen Konfigurationseintrag als Umgebungsvariable an einen Container übergeben

7.4.4 Alle Einträge einer Konfigurationszuordnung auf einmal als Umgebungsvariablen übergeben

7.4.5 Einen Konfigurationseintrag als Befehlszeilenargument übergeben

7.4.6 Konfigurationsdateien mithilfe eines configMap-Volumes verfügbar machen

7.4.7 Die Konfiguration einer Anwendung ohne Neustart ändern

7.5 Sensible Daten mithilfe von Geheimnissen an Container übergeben

7.5.1 Einführung in Geheimnisse

7.5.2 Das Geheimnis default-token

7.5.3 Ein Geheimnis erstellen

7.5.4 Unterschiede zwischen Konfigurationszuordnungen und Geheimnissen

7.5.5 Das Geheimnis in einem Pod verwenden

7.5.6 Geheimnisse zum Abrufen von Images

7.6 Zusammenfassung

8 Von Anwendungen aus auf Podmetadaten und andere Ressourcen zugreifen

8.1 Metadaten über die Downward-API übergeben

8.1.1 Die verwendbaren Metadaten

8.1.2 Metadaten über Umgebungsvariablen verfügbar machen

8.1.3 Metadaten über Dateien in einem downwardAPI-Volume übergeben

8.2 Kommunikation mit dem Kubernetes-API-Server

8.2.1 Die REST-API von Kubernetes

8.2.2 Von einem Pod aus mit dem API-Server kommunizieren

8.2.3 Botschaftercontainer zur Vereinfachung der Kommunikation mit dem API-Server

8.2.4 Clientbibliotheken zur Kommunikation mit dem API-Server

8.3 Zusammenfassung

9 Deployments: Anwendungen deklarativ aktualisieren

9.1 Anwendungen in Pods aktualisieren

9.1.1 Alte Pods löschen und anschließend durch neue ersetzen

9.1.2 Neue Pods starten und danach die alten löschen

9.2 Automatische schrittweise Aktualisierung mit einem Replikationscontroller

9.2.1 Die ursprüngliche Version der Anwendung ausführen

9.2.2 Die schrittweise Aktualisierung mit kubectl durchführen

9.2.3 Warum ist kubectl rolling-update veraltet?

9.3 Deployments zur deklarativen Verwaltung von Anwendungen

9.3.1 Ein Deployment erstellen

9.3.2 Ein Deployment aktualisieren

9.3.3 Eine Bereitstellung zurücknehmen

9.3.4 Die Rolloutrate festlegen

9.3.5 Den Rolloutvorgang anhalten

9.3.6 Das Rollout fehlerhafter Versionen verhindern

9.4 Zusammenfassung

10 StatefulSets: Replizierte statusbehaftete Anwendungen bereitstellen

10.1 Statusbehaftete Pods replizieren

10.1.1 Mehrere Replikate mit jeweils eigenem Speicher ausführen

10.1.2 Eine unveränderliche Identität für jeden Pod bereitstellen

10.2 Statussätze

10.2.1 Statussätze und Replikationssätze im Vergleich

10.2.2 Unveränderliche Netzwerkidentität

10.2.3 Eigenen beständigen Speicher für jede Podinstanz zuweisen

10.2.4 Garantien von Statussätzen

10.3 Statussätze nutzen

10.3.1 Die Anwendung und das Containerimage erstellen

10.3.2 Die Anwendung mithilfe eines Statussatzes bereitstellen

10.3.3 Die Pods untersuchen

10.4 Peers im Statussatz finden

10.4.1 Die Peer-Ermittlung über DNS einrichten

10.4.2 Einen Statussatz aktualisieren

10.4.3 Den Clusterdatenspeicher ausprobieren

10.5 Umgang mit Knotenausfällen

10.5.1 Die Trennung eines Knotens vom Netzwerk simulieren

10.5.2 Den Pod manuell löschen

10.6 Zusammenfassung

Teil III: Fortgeschrittene Themen

11 Interne Mechanismen von Kubernetes

11.1 Die Architektur

11.1.1 Die verteilte Natur der Kubernetes-Komponenten

11.1.2 Verwendung von etcd

11.1.3 Aufgaben des API-Servers

11.1.4 Benachrichtigungen des API-Servers über Ressourcenänderungen

11.1.5 Der Scheduler

11.1.6 Die Controller im Controller-Manager

11.1.7 Die Rolle des Kubelets

11.1.8 Die Rolle des Kubernetes-Dienstproxys

11.1.9 Kubernetes-Add-ons

11.1.10 Zusammenfassung

11.2 Kooperation der Controller

11.2.1 Die betroffenen Komponenten

11.2.2 Die Abfolge der Ereignisse

11.2.3 Clusterereignisse beobachten

11.3 Laufende Pods

11.4 Das Podnetzwerk

11.4.1 Anforderungen an das Netzwerk

11.4.2 Funktionsweise des Netzwerks

11.4.3 CNI

11.5 Implementierung von Diensten

11.5.1 Der Kube-Proxy

11.5.2 Iptables-Regeln

11.6 Cluster mit hoher Verfügbarkeit

11.6.1 Anwendungen hochverfügbar machen

11.6.2 Die Komponenten der Kubernetes-Steuerebene hochverfügbar machen

11.7 Zusammenfassung

12 Sicherheit des Kubernetes-API-Servers

12.1 Authentifizierung

12.1.1 Benutzer und Gruppen

12.1.2 Dienstkonten

12.1.3 Dienstkonten erstellen

12.1.4 Ein Dienstkonto mit einem Pod verknüpfen

12.2 Rollengestützte Zugriffssteuerung

12.2.1 Das RBAC-Autorisierungs-Plug-in

12.2.2 RBAC-Ressourcen

12.2.3 Rollen und Rollenbindungen

12.2.4 Clusterrollen und Clusterrollenbindungen

12.2.5 Standardclusterrollen und -clusterrollenbindungen

12.2.6 Berechtigungen bedachtsam gewähren

12.3 Zusammenfassung

13 Sicherheit der Clusterknoten und des Netzwerks

13.1 Die Namespaces des Hostknotens in einem Pod verwenden

13.1.1 Den Netzwerknamespace des Knotens in einem Pod verwenden

13.1.2 Bindung an einen Hostport ohne Verwendung des Host-Netzwerknamespace

13.1.3 Den PID- und den IPC-Namespace des Knotens verwenden

13.2 Den Sicherheitskontext eines Containers einrichten

13.2.1 Einen Container unter einer bestimmten Benutzer-ID ausführen

13.2.2 Die Ausführung eines Containers als root verhindern

13.2.3 Pods im privilegierten Modus ausführen

13.2.4 Einem Container einzelne Kernelfähigkeiten hinzufügen

13.2.5 Fähigkeiten von einem Container entfernen

13.2.6 Prozesse am Schreiben im Dateisystem des Containers hindern

13.2.7 Gemeinsame Nutzung von Volumes durch Container mit verschiedenen Benutzer-IDs

13.3 Die Bearbeitung der Sicherheitsmerkmale in einem Pod einschränken

13.3.1 Podsicherheitsrichtlinien

13.3.2 Die Richtlinien runAsUser, fsGroup und supplementalGroups

13.3.3 Zulässige, unzulässige und Standardfähigkeiten festlegen

13.3.4 Die verwendbaren Arten von Volumes einschränken

13.3.5 Benutzern und Gruppen unterschiedliche Podsicherheitsrichtlinien zuweisen

13.4 Das Podnetzwerk isolieren

13.4.1 Die Netzwerkisolierung in einem Namespace aktivieren

13.4.2 Einzelnen Pods im Namespace die Verbindung zu einem Serverpod erlauben

13.4.3 Das Netzwerk zwischen Kubernetes-Namespaces isolieren

13.4.4 Verwendung der CIDR-Schreibweise zur Isolierung

13.4.5 Den ausgehenden Datenverkehr von Pods einschränken

13.5 Zusammenfassung

14 Die Computerressourcen eines Pods verwalten

14.1 Ressourcen für die Container eines Pods anfordern

14.1.1 Pods mit Ressourcenanforderungen erstellen

14.1.2 Einfluss der Ressourcenanforderungen auf die Zuteilung zu Knoten

14.1.3 Der Einfluss der CPU-Anforderungen auf die CPU-Zeitzuteilung

14.1.4 Benutzerdefinierte Ressourcen definieren und anfordern

14.2 Die verfügbaren Ressourcen für einen Container einschränken

14.2.1 Harte Grenzwerte für die von einem Container verwendeten Ressourcen festlegen

14.2.2 Überschreiten der Grenzwerte

14.2.3 Grenzwerte aus der Sicht der Anwendungen in den Containern

14.3 QoS-Klassen für Pods

14.3.1 Die QoS-Klasse eines Pods festlegen

14.3.2 Auswahl des zu beendenden Prozesses bei zu wenig Speicher

14.4 Standardanforderungen und -grenzwerte für die Pods in einem Namespace festlegen

14.4.1 Der Grenzwertbereich

14.4.2 Einen Grenzwertbereich erstellen

14.4.3 Die Grenzwerte durchsetzen

14.4.4 Standardanforderungen und -grenzwerte anwenden

14.5 Die in einem Namespace insgesamt verfügbaren Ressourcen beschränken

14.5.1 Ressourcenkontingente

14.5.2 Kontingente für persistenten Speicher festlegen

14.5.3 Die Höchstzahl der Objekte in einem Namespace beschränken

14.5.4 Kontingente für einzelne Podstatus und QoS-Klassen festlegen

14.6 Die Ressourcennutzung der Pods überwachen

14.6.1 Die tatsächliche Ressourcennutzung erfassen

14.6.2 Verlaufsdaten des Ressourcenverbrauchs speichern und analysieren

14.7 Zusammenfassung

15 Automatische Skalierung von Pods und Clusterknoten

15.1 Automatische horizontale Podskalierung

15.1.1 Der Vorgang der automatischen Skalierung

15.1.2 Skalierung auf der Grundlage der CPU-Nutzung

15.1.3 Skalierung auf der Grundlage der Speichernutzung

15.1.4 Skalierung auf der Grundlage anderer Messgrößen

15.1.5 Geeignete Messgrößen für die automatische Skalierung auswählen

15.1.6 Herunterskalieren auf null Replikate

15.2 Automatische vertikale Podskalierung

15.2.1 Ressourcenanforderungen automatisch einrichten

15.2.2 Ressourcenanforderungen von laufenden Pods ändern

15.3 Horizontale Skalierung von Clusterknoten

15.3.1 Der Cluster-Autoskalierer

15.3.2 Den Cluster-Autoskalierer aktivieren

15.3.3 Die Unterbrechung von Diensten beim Herunterskalieren des Clusters minimieren

15.4 Zusammenfassung

16 Erweiterte Planung

16.1 Pods mithilfe von Mängeln und Tolerierungen von bestimmten Knoten fernhalten

16.1.1 Mängel und Tolerierungen

16.1.2 Einem Knoten benutzerdefinierte Mängel hinzufügen

16.1.3 Tolerierungen zu Pods hinzufügen

16.1.4 Verwendungszwecke für Mängel und Tolerierungen

16.2 Knotenaffinität

16.2.1 Feste Knotenaffinitätsregeln aufstellen

16.2.2 Knotenprioritäten bei der Zuteilung eines Pods

16.3 Pods mit Affinitäts- und Antiaffinitätsregeln auf denselben Knoten unter­bringen

16.3.1 Podaffinitätsregeln zur Bereitstellung von Pods auf demselben Knoten

16.3.2 Pods im selben Schaltschrank, in derselben Verfügbarkeitszone oder derselben geografischen Region bereitstellen

16.3.3 Präferenzen statt fester Regeln für die Podaffinität angeben

16.3.4 Pods mit Antiaffinitätsregeln voneinander getrennt halten

16.4 Zusammenfassung

17 Best Practices für die Anwendungsentwicklung

17.1 Das Gesamtbild

17.2 Der Lebenszyklus eines Pods

17.2.1 Beendigung und Verlegung von Anwendungen

17.2.2 Tote oder teilweise tote Pods neu bereitstellen

17.2.3 Pods in einer bestimmten Reihenfolge starten

17.2.4 Lebenszyklushooks

17.2.5 Pods herunterfahren

17.3 Die ordnungsgemäße Verarbeitung aller Clientanforderungen sicherstellen

17.3.1 Unterbrechungen von Clientverbindungen beim Hochfahren eines Pods verhindern

17.3.2 Unterbrechungen von Clientverbindungen beim Herunterfahren eines Pods verhindern

17.4 Einfache Ausführung und Handhabung von Anwendungen in Kubernetes

17.4.1 Einfach zu handhabende Containerimages erstellen

17.4.2 Images sauber kennzeichnen

17.4.3 Mehrdimensionale statt eindimensionaler Labels

17.4.4 Ressourcen mit Anmerkungen beschreiben

17.4.5 Gründe für die Beendigung eines Prozesses angeben

17.4.6 Anwendungsprotokolle

17.5 Empfohlene Vorgehensweisen für Entwicklung und Tests

17.5.1 Anwendungen während der Entwicklung außerhalb von Kubernetes ausführen

17.5.2 Minikube für die Entwicklung

17.5.3 Versionssteuerung und Manifeste zur automatischen Bereitstellung von Ressourcen

17.5.4 Ksonnet als Alternative zu YAML- und JSON-Manifesten

17.5.5 Continuous Integration und Continuous Delivery (CI/CD)

17.6 Zusammenfassung

18 Kubernetes erweitern

18.1 Eigene API-Objekte definieren

18.1.1 Eigene Ressourcendefinitionen

18.1.2 Benutzerdefinierte Ressourcen mit benutzerdefinierten Controllern automatisieren

18.1.3 Benutzerdefinierte Objekte validieren

18.1.4 Einen benutzerdefinierten API-Server für benutzerdefinierte Objekte bereitstellen

18.2 Kubernetes mit dem Kubernetes-Dienstkatalog erweitern

18.2.1 Der Dienstkatalog

18.2.2 Der API-Server des Dienstkatalogs und der Controller-Manager

18.2.3 Dienstbroker und die API OpenServiceBroker

18.2.4 Dienste bereitstellen und nutzen

18.2.5 Aufheben der Bindung und der Bereitstellung

18.2.6 Vorteile des Dienstkatalogs

18.3 Plattformen auf der Grundlage von Kubernetes

18.3.1 Die Containerplattform Red Hat OpenShift

18.3.2 Deis Workflow und Helm

18.4 Zusammenfassung

Anhang A: Verwendung von kubectl für mehrere Cluster

A.1 Umschalten zwischen Minikube und Google Kubernetes Engine

A.1.1 Umschalten zu Minikube

A.1.2 Umschalten zu GKE

A.2 Verwendung von kubectl für mehrere Cluster oder Namespaces

A.2.1 Den Speicherort der Konfigurationsdatei festlegen

A.2.2 Der Inhalt der Konfigurationsdatei

A.2.3 Konfigurationseinträge auflisten, hinzufügen und ändern

A.2.4 Verwendung von kubectl mit verschiedenen Clustern, Benutzern und Kontexten

A.2.5 Umschalten zwischen Kontexten

A.2.6 Kontexte und Cluster auflisten

A.2.7 Kontexte und Cluster löschen

Anhang B: Einen Cluster mit mehreren Knoten mit kubeadm erstellen

B.1 Das Betriebssystem und die erforderlichen Pakete einrichten

B.1.1 Die virtuelle Maschine erstellen

B.1.2 Den Netzwerkadapter für die VM einrichten

B.1.3 Das Betriebssystem installieren

B.1.4 Docker und Kubernetes installieren

B.1.5 Die VM klonen

B.2 Den Master mit kubeadm konfigurieren

B.2.1 Ausführung der Komponenten durch kubeadm

B.3 Arbeitsknoten mit kubeadm einrichten

B.3.1 Das Containernetzwerk einrichten

B.4 Vom lokalen Computer auf den Cluster zugreifen

Anhang C: Andere Containerlaufzeitumgebungen verwenden

C.1 Docker durch rkt ersetzen

C.1.1 Kubernetes zur Verwendung von rkt einrichten

C.1.2 rkt in Minikube ausprobieren

C.2 Andere Containerlaufzeiten über die CRI verwenden

C.2.1 CRI-O

C.2.2 Anwendungen in VMs statt in Containern ausführen

Anhang D: Clusterverbund

D.1 Der Kubernetes-Clusterverbund

D.2 Die Architektur

D.3 Verbund-API-Objekte

D.3.1 Verbundversionen der Kubernetes-Ressourcen

D.3.2 Funktionsweise von Verbundressourcen

Anhang E: Kubernetes-Ressourcen in diesem Buch

Index