So installieren Sie Kubernetes unter Ubuntu
Die manuelle Bereitstellung von Docker-Containern auf mehreren Servern kann sehr zeitaufwendig sein und den Plan jedes Systemadministrators, der mit dieser Aufgabe betraut ist, vollständig in Anspruch nehmen. In der modernen IT-Branche nimmt die Beliebtheit von Clouds, Microservices und Containern weiter zu, weshalb Lösungen wie Kubernetes entwickelt wurden.
Kubernetes ist eine Open-Source-Lösung für das Management und die Orchestrierung von Containern, mit der Sie einen Cluster aufbauen können, um die Bereitstellung von Containern in verteilten Umgebungen zu vereinfachen und eine hohe Verfügbarkeit für containerisierte Anwendungen zu gewährleisten. Ziel dieses Blogbeitrags ist es, zu erläutern, wie Sie Kubernetes unter Ubuntu installieren, um Anwendungen in Docker-Containern auszuführen.
Anforderungen und Systemkonfiguration für die Installation von Kubernetes unter Ubuntu
Der Kubernetes-Cluster besteht aus Master-Knoten und Worker-Knoten. Die Hardwarekonfiguration hängt von Ihren Anforderungen und den Anwendungen ab, die Sie in Docker-Containern ausführen möchten. Die Mindestanforderungen an die Hardware für die Installation von Kubernetes unter Ubuntu lauten:
- Mindestens eine x86/x64-CPU (Central Processor Unit) mit 2 Kernen
- 2 GB RAM (Random Access Memory) oder mehr
- Internetzugang
Ports, die für die Installation von Kubernetes unter Ubuntu geöffnet werden müssen:
| Protokoll und Portbereich | Quelle | Zweck | Richtung |
| TCP 443 | Worker-Knoten, Endbenutzer, API-Anfragen | Kubernetes-API-Server | Eingehender Datenverkehr zum Master-Knoten |
| TCP 10250 | Master-Knoten | Port für den Kubelet-Zustandscheck des Worker-Knotens | Eingehender Datenverkehr zum Worker-Knoten |
| TCP 30000-32767 | Externe Anwendungsclients | Standard-Portbereich für die Bereitstellung externer Dienste | |
| UDP 8285 | Worker-Knoten | UDP-Backend des Flannel-Overlay-Netzwerks | |
| UDP 8472 | Worker-Knoten | VXLAN-Backend des Flannel-Overlay-Netzwerks | |
| TCP 179 | Worker-Knoten | Nur erforderlich, wenn ein Calico-BGP-Netzwerk verwendet wird | |
| TCP 2379-2380 | Master-Knoten | etcd-Server-Client-API | etcd-Knoten (eingehend) |
| TCP 2379-2380 | Worker-Knoten | etcd-Server-Client-API, die erforderlich ist, wenn Flannel oder Calico verwendet wird |
Standardmäßig ist die iptables-Firewall unter Ubuntu installiert, es sind jedoch keine Blockierungsregeln „von Haus aus“ vorhanden. Wenn Sie also Ubuntu installieren, um Kubernetes auszuprobieren, müssen Sie die Firewall-Regeln nicht bearbeiten. Kube-proxy fügt zunächst seine eigenen iptables-Ketten ein und fügt anschließend zwei iptables-Regeln hinzu. Bei diesen Regeln handelt es sich um „KUBE-EXTERNAL-SERVICES“ und „KUBE-FIREWALL“, die am Anfang der INPUT-Kette eingefügt werden.
Die Installation von Kubernetes unter Ubuntu ist sowohl auf physischen als auch auf virtuellen Maschinen möglich. Allgemein wird empfohlen, die neueste Version von 64-Bit-Ubuntu Linux zu verwenden. Der heutige Blogbeitrag beschreibt die Installation von Kubernetes auf Ubuntu 18.04 LTS, das auf VMware-VMs läuft. Als erster Kubernetes-Bereitstellungstyp wird die Konfiguration mit einem Master-Knoten erläutert, wobei zwei Worker-Knoten für den Kubernetes-Cluster verwendet werden. In der folgenden Tabelle finden Sie die bedingte Anzahl der Knoten, die Knotenrollen, die Hostnamen und die IP-Adressen der im Beispiel verwendeten Maschinen.
| Nr. | Rolle des Knotens | IP-Adresse | Hostname |
| 1 | Master | 192.168.101.21 | docker-nakivo21 |
| 2 | Worker | 192.168.101.31 | docker-nakivo31 |
| 3 | Worker | 192.168.101.32 | docker-nakivo32 |
Sie können VMs verwenden, die auf ESXi-Hosts laufen, wenn Sie VMware vSphere nutzen, oder Sie können VMs auf VMware Workstation ausführen, das auf Ihrem PC unter Linux oder Windows installiert ist. Im heutigen Beispiel verwenden wir VMs, die auf VMware Workstation laufen. Die VMs nutzen das NAT- Netzwerk mit Internetzugang. Wenn Sie VirtualBox gegenüber VMware bevorzugen, können Sie dieses ebenfalls verwenden.
Die IP-Adresse des Host-Rechners: 10.10.10.53
Die IP-Adresse des virtuellen Gateways für das NAT-Netzwerk (VMNet8): 192.168.101.2
Der gleiche Linux-Benutzer ist auf allen Ubuntu-Maschinen vorhanden: kubernetes-user
VM-Konfiguration: 2 CPUs, 4 GB RAM, 20 GB virtuelle Festplatte
Sie können die IP-Adressen des VMNet8 ändern, indem Sie in VMware Workstation zu Edit > Virtual Network Editor navigieren.
Zum besseren Verständnis werden im heutigen Beispiel alle Komponenten manuell unter Linux installiert, ohne Automatisierungstools wie Ansible.
Bereitstellung der Ubuntu-VM
Erstellen Sie eine neue VM mit dem Namen docker-nakivo21 .
Installieren Sie Ubuntu 64-Bit auf der ersten Maschine und legen Sie den Hostnamen und den Benutzernamen fest.
VM-Name: docker-nakivo21
Benutzername: kubernetes-user
Installieren Sie VMware Tools nach der ersten Anmeldung am installierten Betriebssystem. Wenn Sie physische Maschinen verwenden, benötigen Sie VMware Tools nicht und können diesen Schritt überspringen.
Hinweis : Das $ Zeichen am Anfang bedeutet, dass ein Befehl als normaler Benutzer ausgeführt wird ( kubernetes-user in diesem Fall). Beginnt die Zeichenfolge mit dem # Zeichen, muss der Befehl als Root-Benutzer ausgeführt werden. Der sudo (Benutzerwechsel oder Superuser-Ausführung) Befehl ermöglicht es Ihnen, Befehle als ein anderer Benutzer, einschließlich des Superusers, auszuführen. Sie können sudo -i eingeben, um im Terminal Superuser-Rechte zu erhalten. Drücken Sie Strg+D, um den Superuser-Modus zu verlassen.
Sie können die VMware-Tools von dem mit dem VMware-Hypervisor bereitgestellten ISO-Image oder aus Linux-Repositories (unten erklärt) installieren.
$ sudo apt-get install open-vm-tools
Wenn Sie ein erweitertes Desktop-Erlebnis wie eine geteilte Zwischenablage, Drag-and-Drop von Dateien usw. benötigen, führen Sie aus:
$ sudo apt-get install open-vm-tools-desktop
Starten Sie die VM neu.
$ init 6
Konfigurieren Sie Ihre Ubuntu-Maschine, bevor Sie Kubernetes installieren
Einige Vorbereitungen müssen getroffen werden, bevor Sie Kubernetes auf Ubuntu-Maschinen installieren. Zuerst müssen Sie die statische IP-Adresse und den Hostnamen für jeden gewöhnlichen Server konfigurieren.
Stellen Sie die statische IP-Adresse ein
Wie bei jeder anderen Art von Cluster wird die Verwendung statischer IP-Adressen auf Knoten empfohlen.
Installieren Sie Linux-Netzwerktools, bevor Sie die IP-Adresse einstellen.
$ sudo apt-get install net-tools
Geben Sie ifconfig ein, um die aktuelle IP-Adresse Ihrer Ubuntu-VM zu überprüfen.
Sie sehen, dass die IP-Adresse automatisch über DHCP bezogen wird. Merken Sie sich den Namen der Netzwerkschnittstelle. In diesem Beispiel ist der Name ens33 . Der Name der ersten Ethernet-Netzwerkschnittstelle ist normalerweise eth0 für physische Maschinen.
Sie benötigen einen Texteditor zum Bearbeiten von Konfigurationsdateien. Installieren Sie vim als Texteditor.
$ sudo apt-get install vim
In den neuesten Ubuntu-Versionen wird die Netzwerkkonfiguration in einer YAML-Datei festgelegt. Öffnen Sie die Netzwerkkonfigurations-YAML-Datei in vim.
$ sudo vim /etc/netplan/01-network-manager-all.yaml
Die Standardansicht der Konfigurationsdatei ist:
Bearbeiten Sie diese Netzwerkkonfigurationsdatei wie unten gezeigt:
network:
version: 2
renderer: networkd
ethernets:
ens33:
dhcp4: no
addresses: [192.168.101.21/24]
gateway4: 192.168.101.2
nameservers:
addresses: [192.168.101.2,8.8.8.8]
Änderungen speichern und beenden.
:wq
$ sudo netplan try
Drücken Sie ENTER, um die neue Konfiguration zu akzeptieren.
Überprüfen Sie, ob Ihre Netzwerkkonfiguration geändert wurde und versuchen Sie, z.B. nakivo.com anzupingen.
$ ifconfig
$ ping nakivo.com
Konfigurieren Sie einen Hostnamen
Überprüfen Sie Ihren aktuellen Hostnamen.
$ hostnamectl
Wie Sie sich erinnern, wurde der Hostname für die erste VM, nämlich docker-nakivo21 , bereits während der Installation eingerichtet. Um den Hostnamen zu ändern, tun Sie Folgendes (dies wird für die Konfiguration der zweiten und dritten VMs nach dem Klonen benötigt. Diese beiden VMs sollen als Worker-Knoten konfiguriert werden):
Wenn Sie beispielsweise den Hostnamen auf docker-nakivo21 auf der ersten VM ändern möchten, führen Sie aus: $ sudo hostnamectl set-hostname docker-nakivo21
Überprüfen Sie, ob der neue Hostname angewendet wurde.
$ less /etc/hostname
Bearbeiten Sie die Hosts-Datei .
$ sudo vim /etc/hosts
Der Inhalt der Hosts-Datei muss wie folgt aussehen:
127.0.0.1 localhost
127.0.1.1 docker-nakivo21
Starten Sie den Rechner neu.
$ init 6
Deaktivieren Sie eine Auslagerungsdatei
Die Verwendung einer Auslagerungsdatei (Swap-Partition) wird von Kubernetes nicht unterstützt, und die Deaktivierung von „swappiness“ ist erforderlich, um Kubernetes erfolgreich auf Ubuntu zu installieren.
Deaktivieren Sie eine Auslagerungsdatei, um eine hohe CPU-Auslastung durch kubelet zu verhindern.
$ sudo swapoff -a
Bearbeiten Sie /etc/fstab und kommentieren Sie die Zeile mit dem # Zeichen aus.
$ sudo vim /etc/fstab
#/swapfile Keine Swap-Partition Swap sw 0 0
Das Gleiche können Sie mit sed mit nur einem einzigen Befehl erreichen:
$ sudo sed -i '/ swap / s/^(.*)$/#1/g' /etc/fstab
Deaktivieren Sie den Swap in sysctl.conf
$ sudo echo "vm.swappiness=0" | sudo tee --append /etc/sysctl.conf
Dabei ist 0 der Prozentsatz der Swap-Neigung. In diesem Fall kann der Swap nur genutzt werden, wenn der Arbeitsspeicher (RAM) nicht mehr ausreicht (standardmäßig wird der Swap genutzt, wenn mehr als 60 % des Arbeitsspeichers belegt sind).
Konfigurationsänderungen ohne Neustart anwenden.
$ sudo sysctl -p
Hinweis : Wenn die Swap-Partition nicht deaktiviert ist, kann der Prozess kswapd0 von Ubuntu Linux unter Kubernetes eine große Menge an CPU-Ressourcen auf Ihrem Rechner beanspruchen, was dazu führt, dass Anwendungen nicht mehr reagieren und das System abstürzt. Dies geschieht, wenn dem Betriebssystem der Arbeitsspeicher ausgeht und alte Speicherseiten von einem Linux-Kernel-Prozess in den Swap-Speicher verschoben werden. Aus unerfindlichen Gründen geht manchmal etwas schief, und es entsteht eine Endlosschleife, die alle CPU-Ressourcen beansprucht. Auf dem folgenden Screenshot sehen Sie eine hohe CPU-Auslastung durch den Prozess kswapd0 , wenn Kubernetes unter Ubuntu installiert ist. Der durchschnittliche Auslastungswert ist übermäßig hoch.
Falls kswapd0 Ihre CPU weiterhin überlastet, führen Sie den folgenden Befehl aus, um alle Speicher-Caches zu leeren und kswapd0 zu beenden (als Root ausführen).
# echo 1 > /proc/sys/vm/drop_caches
Fahren Sie die VM herunter.
$ init 0
Diese teilweise konfigurierte virtuelle Maschine ( docker-nakivo21 ) soll als Master-Knoten verwendet werden. Erstellen Sie zwei Maschinen, die als Worker-Knoten dienen sollen. Wenn Sie physische Maschinen verwenden, wiederholen Sie die vorherigen Schritte manuell (oder nutzen Sie Automatisierungstools wie Ansible, um mehrere Linux-Maschinen gleichzeitig über SSH zu konfigurieren). Da im aktuellen Beispiel VMs verwendet werden, können diese geklont werden, um bei der Vorbereitung der Umgebung für die Installation von Kubernetes auf Ubuntu-Maschinen Zeit zu sparen.
VM klonen
Klonen Sie Ihre erste VM. Wenn Sie VMware ESXi verwenden, können Sie die integrierte Klonfunktion nutzen. Sie können mehr über dieses Thema erfahren, indem Sie unseren Blogbeitrag über Klonen von VMs von VM-Vorlagen lesen. Wenn Sie VMware Workstation verwenden, können Sie auch VMs durch zwei Methoden klonen (eingebautes Klone-Tool und manuell). Sie können auf VM > Manage > Clone klicken, um einen verknüpften Klon zu erstellen. Lassen Sie uns einen vollständigen Klon der Ersten VM erstellen und die VM-Dateien manuell kopieren. In diesem Fall werden die Dateien von dem docker-nakivo21 Verzeichnis zu docker-nakivo31. kopiert. Die Verzeichnisse müssen manuell erstellt werden, bevor die VM-Dateien kopiert werden.
Bearbeiten Sie die VMX-Datei, da sich der VM-Name und der Pfad zur virtuellen Festplattendatei geändert haben.
displayName = "docker-nakivo31"
scsi0:0.fileName = "C:VirtualKUBERNETESdocker-nakivo31docker-nakivo31.vmdk"
nvram = "docker-nakivo31.nvram"
Die VM, die als erster Worker-Knoten verwendet wird, wurde nun erstellt. Klonen Sie die erste VM erneut, um den zweiten Worker-Knoten des Kubernetes-Clusters vorzubereiten.
Bearbeiten Sie die VMX-Datei für die dritte VM (den zweiten Worker-Knoten), wie Sie es zuvor getan haben.
displayName = "docker-nakivo32"
scsi0:0.fileName = "C:VirtualKUBERNETESdocker-nakivo31docker-nakivo32.vmdk"
nvram = "docker-nakivo32.nvram"
Öffnen Sie die VM-Klone in VMware Workstation (File> Open und wählen Sie die VMX-Datei der VM aus), oder doppelklicken Sie einfach die VMX-Datei der VM. Schalten Sie drei virtuelle Maschinen ein (Ihre eine Quell-VM und zwei VM-Klone). Klicken Sie auf Ich habe es kopiert , wenn Sie dazu aufgefordert werden.
Hinweis : Wenn Sie virtuelle Maschinen verwenden, bearbeiten Sie die IP-Adresse und den Hostnamen auf jedem VM-Klon, sobald die VMs geklont wurden. Wenn Sie physische Maschinen verwenden, befolgen Sie alle vorherigen Schritte entsprechend Ihren IP-Adressen und Hostnamen für jede Maschine.
Konfigurieren von IP-Adressen und Hostnamen auf VMs
Ändern Sie die IP-Adresse und den Hostnamen auf docker-nakivo31 und docker-nakivo32 VMs (wie oben gezeigt).
Wiederholen Sie die in den obigen Abschnitten erklärten Schritte, um die statischen IP-Adressen und Hostnamen zu konfigurieren.
Die IP-Adresse muss sein: 192.168.101.31 und 192.168.101.32 ; die Hostnamen müssen docker-nakivo31 und docker-nakivo32 entsprechend sein auf Worker-Knoten.
Alle Maschinen müssen so konfiguriert sein, dass sie Hostnamen von Knoten in IP-Adressen auflösen können. Sie können einen DNS-Server konfigurieren oder die hosts -Datei auf jeder Maschine manuell bearbeiten. Bearbeiten wir hosts .
Fügen Sie die folgenden Zeichenfolgen in die hosts -Datei auf jeder Maschine ein ( docker-nakivo21 , docker-nakivo31 , docker-nakivo32 ).
$ sudo vim /etc/hosts
Fügen Sie diese Zeilen in die hosts -Datei ein:
192.168.101.21 docker-nakivo21
192.168.101.31 docker-nakivo31
192.168.101.32 docker-nakivo32
Pingen Sie andere Hosts von jedem Host aus an, um sicherzustellen, dass die Hostnamen aufgelöst werden: $ ping docker-nakivo21
$ ping docker-nakivo31
$ ping docker-nakivo32
Konfigurieren Sie den SSH-Zugriff auf allen Hosts (VMs)
Konfigurieren Sie den SSH-Zugriff auf allen Hosts. Installieren Sie den OpenSSH-Server, indem Sie die Befehle auf jedem Rechner ausführen.
$ sudo apt-get install openssh-server
Gehen Sie ins Home-Verzeichnis von kubernetes-user und erstellen Sie das SSH-Schlüsselpaar (ein Satz kryptografischer Schlüssel, bestehend aus einem privaten und einem öffentlichen Schlüssel). SSH-Schlüsselpaare können zur Anmeldung an der Remote-Linux-Konsole ohne Passwort verwendet werden. Der öffentliche Schlüssel kann auf einen Rechner kopiert werden, von dem aus Sie sich verbinden müssen, während der private Schlüssel streng geheim ist und auf dem Rechner gespeichert werden muss, mit dem Sie sich verbinden möchten.
$ ssh-keygen
Es ist nicht erforderlich, ein Passwort für die Schlüsselerstellung einzugeben (das Passwort ist optional).
Kopieren Sie die Schlüssel auf andere Ubuntu-Maschinen:
$ ssh-copy-id kubernetes-user@192.168.101.31
$ ssh-copy-id kubernetes-user@192.168.101.32
Geben Sie Ihr Benutzerpasswort ein, um das Kopieren der Schlüssel zu bestätigen.
Versuchen Sie, die Verbindung zur zweiten Maschine ( docker-nakivo31 ) als kubernetes-user (ein regulärer Benutzer) herzustellen.
$ ssh 'kubernetes-user@192.168.101.31'
Dann testen Sie die Verbindung zur dritten Maschine ( docker-nakivo32 ).
$ ssh 'kubernetes-user@192.168.101.32'
Sie werden nach erfolgreicher Verbindung den Namen der Remote-Maschine in der Befehlszeile Ihrer Konsole sehen.
Drücken Sie Ctrl+D, um die Remote-Konsole zu verlassen.
Wie kopiere ich den Schlüssel, um sich als Root-Benutzer per SSH zu verbinden?
Da Sie Root-Rechte in Kubernetes benötigen, erstellen wir Schlüssel zur Konfiguration des SSH-Zugangs für den Root-Benutzer. Führen Sie die folgenden Befehle auf allen Maschinen (docker-nakivo21, docker-nakivo31 und docker-nakivo32) aus, die per SSH als Root-Benutzer zugänglich sein müssen.
$ sudo -i
Bearbeiten Sie die SSH-Server-Konfigurationsdatei.
# vim /etc/ssh/sshd_config
Fügen Sie die folgende Zeichenfolge ein oder bearbeiten Sie sie in dieser Datei.
PermitRootLogin yes
Starten Sie den SSH-Server-Daemon neu.
# /etc/init.d/ssh stop
# /etc/init.d/ssh start
Setzen Sie das Root-Passwort (Passwort für den Root-Benutzer).
# passwd
$ cd /home/kubernetes-user/
$ sudo ssh-keygen -t rsa
Kopieren Sie den öffentlichen Schlüssel, um sich per SSH als Root anzumelden (der Schlüssel liegt im Home-Verzeichnis des regulären Benutzers, da der vorherige Befehl aus diesem Verzeichnis ausgeführt wurde).
$ sudo ssh-copy-id -i /home/kubernetes-user/.ssh/id_rsa.pub 127.0.0.1
Falls Ihr Schlüssel im Home-Verzeichnis des Root-Benutzers gespeichert ist, kopieren Sie den Schlüssel mit diesem Befehl:
# ssh-copy-id -i /root/.ssh/id_rsa.pub 127.0.0.1
Bestätigen Sie diesen Vorgang und geben Sie Ihr Passwort ein.
Wiederholen Sie die Aktion, indem Sie den Schlüssel von jeder Maschine auf andere Maschinen kopieren. Führen Sie beispielsweise auf der docker-nakivo21 Maschine aus:
# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.31
# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.32
Machen Sie den öffentlichen Schlüssel autorisiert.
# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keys
Überprüfen Sie, ob Sie sich als Root-Benutzer über SSH auf der lokalen Maschine anmelden können. $ sudo ssh root@127.0.0.1
Versuchen Sie, eine Verbindung von/zu dem Remote-Rechner herzustellen, ohne ein Passwort einzugeben.
$ sudo ssh root@192.168.101.21
$ sudo ssh root@192.168.101.31
$ sudo ssh root@192.168.101.32
Hinweis : Eine Verbindung als Root-Benutzer kann unsicher sein. Stellen Sie keine Verbindung als Root her, wenn dies nicht notwendig ist – es ist besser, sich per SSH als normaler Benutzer zu verbinden und den Befehl sudo zu verwenden.
Docker-Installation
Docker ist die beliebteste von Kubernetes unterstützte Containerplattform für Enterprise-Anwendungen. Installieren Sie Docker auf allen Rechnern. Führen Sie die unten aufgeführten Befehle auf docker-nakivo21 , docker-nakivo31 , docker-nakivo32 aus.
Es besteht jedoch kein Grund zur Eile. Für den ersten Versuch können Sie Docker einfach mit dem üblichen Befehl installieren:
$ sudo apt-get install -y docker.io
Allerdings ist die verwendete Docker-Version in diesem Fall möglicherweise nicht die aktuellste. Beheben wir das, indem wir die neueste Version von Docker installieren.
Installieren Sie zunächst die erforderlichen Pakete.
$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
Curl ist ein universelles, kompaktes Tool, das dafür entwickelt wurde, Daten von/zu einem Host ohne Benutzereingriff unter Verwendung eines der unterstützten Protokolle (HTTP, HTTPS, FTP, FTPS, SFTP, LDAP, LDAPS, IMAP, IMAPS, POP3, POP3S, SCP, SMB, SMTP, TELNET usw.) zu übertragen.
Fügen Sie den GPG-Schlüssel für das offizielle Docker-Repository zu Ihrem Ubuntu-System hinzu:
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
Die Konsolenausgabe muss wie folgt lauten: OK.
Fügen Sie das offizielle Docker-Repository zu Ihrem apt-Paketmanager hinzu:
$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
Aktualisieren Sie die Datenbank des Paketmanagers, nachdem durch den vorherigen Befehl manuelle Änderungen vorgenommen wurden.
$ sudo apt-get update
Überprüfen Sie die Version des Docker-Pakets, das im offiziellen Repository verfügbar ist.
$ apt-cache policy docker-ce
Installieren Sie Docker.
$ sudo apt-get install docker-ce
Sie können die Version von Docker nach der Installation überprüfen.
$ docker --version
In diesem Fall lautet die Ausgabe: Docker-Version 18.09.6, Build 481bc77 .
Starten Sie Docker und stellen Sie sicher, dass der Docker-Daemon beim Systemstart automatisch geladen wird.
$ sudo systemctl start docker
$ sudo systemctl enable docker
Sobald Sie Docker auf allen Rechnern installiert haben, können Sie direkt mit der Installation von Kubernetes unter Ubuntu fortfahren.
Installation von Kubernetes unter Ubuntu und Cluster-Initialisierung
Nun steht der Installation der Kubernetes-Kernkomponenten nichts mehr im Wege.
Führen Sie die Befehle als Root auf allen Rechnern aus, die in den Kubernetes-Cluster aufgenommen werden sollen.
$ sudo -i
Fügen Sie den GPG-Schlüssel für das offizielle Docker-Repository zu Ihrem Ubuntu-System hinzu:
# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
Fügen Sie das offizielle Kubernetes-Repository zur Datenbank der verfügbaren Paket-Repositorys für Ihren apt-Paketmanager hinzu.
# cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
Alternativ können Sie das Repository mit diesem Befehl hinzufügen: # echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.list
Dabei ist tee ein Tool, das die Standardeingabe liest und die Eingabedaten in die Standardausgabe sowie in definierte Dateien schreibt.
Aktualisieren Sie die Paketliste der verfügbaren Repositorys auf Ihrem Ubuntu-System.
# apt-get update
Die Installation von kubectl , kubeadm und kubectl ist für die Installation von Kubernetes unter Ubuntu unerlässlich.
# apt-get install -y kubelet kubeadm kubectl
Installieren Sie keepalived.
# apt-get install keepalived
# systemctl enable keepalived && systemctl start keepalived
Überprüfen Sie, ob der Wert 1 lautet, damit das auf Ubuntu installierte Kubernetes ordnungsgemäß funktioniert.
# sysctl net.bridge.bridge-nf-call-iptables
Um diesen Wert auf 1 zu setzen, führen Sie den folgenden Befehl aus:
sysctl net.bridge.bridge-nf-call-iptables=1
Bearbeiten Sie die kubeadm-Konfigurationsdatei.
# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
Fügen Sie die folgende Zeichenfolge hinter der bestehenden „Environment“-Zeichenfolge ein:
Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”
Cgroups sind Kontrollgruppen, die die Ressourcennutzung wie Prozessor, Arbeitsspeicher, Festplatten-E/A und Netzwerk isolieren.
Führen Sie auf dem Master-Knoten ( docker-nakivo21 ) den Befehl aus, um den Kubernetes-Cluster unter Ubuntu zu initialisieren.
# kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=192.168.101.21
Dabei ist
–pod-network-cidr für den Flannel-Treiber erforderlich. CIDR (Classless Inter-Domain Routing) definiert die Adresse Ihres Overlay-Netzwerks (z. B. Flannel), das später konfiguriert wird. Die Netzmaske legt zudem fest, wie viele Pods pro Knoten ausgeführt werden können. Die CIDR-Netzwerkadresse und die für Flannel verwendete Netzwerkadresse müssen identisch sein.
–apiserver-advertise-address=192.168.101.21 definiert die IP-Adresse, die von Kubernetes als API-Server bekannt gegeben wird.
Lesen Sie die am Ende des Textes angezeigten Befehle zur Ausgabe und Speicherung. Dies ist ein wichtiger Punkt. Das generierte Token wird benötigt, um Worker-Knoten zum Kubernetes-Cluster hinzuzufügen.
Führen Sie die folgenden Befehle als Benutzer aus, der kubeadm initausgeführt hat. In diesem Fall werden die Befehle als root ausgeführt.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Wenn Sie diese Befehle nicht ausführen, gibt Kubernetes folgende Fehlermeldung aus: Die Verbindung zum Server localhost:8080 wurde abgelehnt – haben Sie den richtigen Host oder Port angegeben?
Kubernetes kopiert diese Konfigurationsdatei nicht automatisch in das Benutzerverzeichnis. Sie sollten diesen Vorgang manuell durchführen.
Überprüfen Sie die zum Cluster hinzugefügten Knoten:
# kubectl get nodes
Im Kubernetes-Cluster, der auf Ubuntu installiert wird, sehen Sie einen Master-Knoten mit dem Status „ “ NotReady . Dies liegt daran, dass das Overlay-Netzwerk noch nicht konfiguriert wurde. Konfigurieren Sie Flannel, um den Status „ “ NotReady des Kubernetes-Master-Knotens zu beheben. Erstellen Sie das Verzeichnis zum Speichern der YAML-Dateien für Docker und Kubernetes, zum Beispiel /home/kubernetes-user/kubernetes/
YAML (Yet Another Markup Language) bietet Ihnen mehr Komfort beim Erstellen von Pods und Bereitstellungen in Kubernetes. Sie können alle Parameter der Container, die bereitgestellt werden sollen, in der YAML-Konfigurationsdatei definieren, anstatt jeden Befehl manuell in der Linux-Konsole auszuführen. YAML-Dateien werden im Zusammenhang mit Kubernetes auch als Manifest-Dateien bezeichnet.
Erstellen Sie die YAML-Konfigurationsdatei mit folgendem Inhalt:
Führen Sie den Befehl aus:
# kubectl apply -f ./kube-flannel.yml
Alternativ finden Sie auf GitHub vorgefertigte kostenlose Beispiele für YAML-Bereitstellungen für Kubernetes.
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml
Überprüfen Sie die Knoten, die dem Kubernetes-Cluster hinzugefügt wurden, den Sie auf Ubuntu bereitstellen:
# kubectl get nodes
Der Status des Master-Knotens lautet nun „Ready“.
Stellen Sie sicher, dass Flannel korrekt eingerichtet wurde:
# kubectl get pods --all-namespaces
Sie können sehen, dass der Flannel-Pod läuft. Dieser Pod besteht aus zwei Containern – dem Flannel-Daemon und einem initContainer, der dazu dient, die CNI-Konfiguration an einem für Kubernetes lesbaren Standort bereitzustellen.
Manchmal kann bei der Installation von Kubernetes unter Ubuntu der folgende Fehler auftreten:
Verbindung zum Server nicht möglich: net/http: TLS-Handshake-Timeout.
Wie lässt sich dieses Problem beheben? Warten Sie einige Sekunden und versuchen Sie es erneut – das reicht oft schon aus.
Namespaces sind logische Einheiten im Kubernetes-Cluster, die Cluster-Ressourcen repräsentieren und als virtuelle Cluster betrachtet werden können. Ein physischer Cluster kann logisch in mehrere virtuelle Cluster unterteilt werden. Die Standard-Namespaces von Kubernetes sind Default , Kube-public und Kube-system . Sie können die Liste der Namespaces abrufen:
# kubectl get namespaces
Wie Sie sich vielleicht erinnern, ist die grundlegende Bereitstellungseinheit in Kubernetes ein Pod – eine Sammlung von Containern, die sich den Netzwerk- und Mount-Namespace teilen. Alle Container des Pods werden auf demselben Kubernetes-Knoten eingeplant. Überprüfen Sie die verfügbaren Pods:
# kubectl -n kube-system get pods
Wenn Sie den Cluster zurücksetzen oder anhalten möchten, führen Sie folgenden Befehl aus:
# kubeadm reset
Auf dem Master-Knoten ist alles in Ordnung. Das bedeutet, dass Sie nun mit der Installation von Kubernetes unter Ubuntu fortfahren und damit beginnen können, dem Cluster Worker-Knoten hinzuzufügen.
Führen Sie auf den Worker-Knoten ( docker-nakivo31 , docker-nakivo32 ) den folgenden Befehl aus:
# kubeadm join 192.168.101.21:6443 --token d8mbzb.uulxu01jbty8yh4z
--discovery-token-ca-cert-hash sha256:65ace7a4ff6fff795abf086f18d5f0d97da71d4639a0d0a6b93f42bea4948a79
Das Token und der Hash wurden, wie Sie sich vielleicht erinnern, nach der Cluster-Initialisierung mit dem Befehl kubeadm init notiert.
Überprüfen Sie auf dem Master-Knoten erneut den Status des Clusters. # kubectl get nodes
Nun sehen Sie einen Master- und zwei Worker-Knoten im Kubernetes-Cluster, die auf Ubuntu-Rechnern laufen.
Sie können die Kubernetes-Konfiguration überprüfen:
# kubectl cluster-info
Bereitstellung eines Pods in Kubernetes
Nun können Sie einen Pod mit Containern in Ihrem Kubernetes-Cluster bereitstellen. Wie Sie sich vielleicht erinnern, sind Container in Kubernetes Teil von Pods. Wenn Sie YAML-Dateien verwenden, legen Sie der Übersichtlichkeit halber ein Verzeichnis an, in dem Sie diese Dateien speichern. Wechseln Sie in dieses Verzeichnis und führen Sie folgende Befehle aus: kubectl apply -f test.yaml
Ein solches Verzeichnis wurde bereits bei der Konfiguration von Flannel erstellt – /home/kubernetes-user/kubernetes/
Nun ist es an der Zeit, einen neuen Pod bereitzustellen. Zunächst müssen Sie eine Bereitstellung erstellen. Eine Bereitstellung ist ein Controller-Konzept, das dazu dient, deklarative Aktualisierungen für Pods und Replica-Sets bereitzustellen. Sie können eine Bereitstellung mit einem einzigen Befehl oder von YAML-Dateien erstellen.
Beispiel 1 – Bereitstellung von MySQL
Erstellen wir in diesem Beispiel eine YAML-Datei. Der Name der Datei lautet mysql-deployment.yaml
Die Konfiguration sehen Sie in der angehängten Datei.
# vim mysql-deployment.yaml
Es gibt zwei gängige Ansätze zum Verwalten von Ressourcen mit kubectl . Was ist der Unterschied zwischen kubectl create und kubectl apply ? Wenn Sie kubectl create verwenden, teilen Sie Kubernetes mit, was Sie erstellen, ersetzen oder löschen möchten; dieser Befehl überschreibt alle Änderungen. Alternativ führt kubectl apply inkrementelle Änderungen an, und dieser Befehl kann verwendet werden, um an einem aktiven Objekt vorgenommene Änderungen zu speichern.
Erstellen Sie eine Bereitstellung:
# kubectl apply -f ./mysql-deployment.yaml
Kubernetes kann Informationen zu Ihrer Bereitstellung anzeigen.
# kubectl describe deployment mysql
Überprüfen Sie Pods:
# kubectl get po
oder
# kubectl get pods
oder
# kubectl get pods -l app=mysql
Wenn der Status des Pods „pending“ lautet, kann dies bedeuten, dass nicht genügend Rechenressourcen zur Verfügung stehen. Versuchen Sie, etwas CPU- und Arbeitsspeicherkapazität hinzuzufügen, um den Status „pending“ des Pods in Kubernetes zu beheben.
Bei Bedarf können Sie den Service löschen:
# kubectl delete service <service_name>
Sie können auch einen Pod löschen:
# kubectl delete pod mysql-7b9b7999d8-nz5tm
Beispiel 2 – nginx bereitstellen
Stellen wir nginx nun mit einer anderen Methode ohne YAML-Dateien bereit.
Erstellen Sie eine Bereitstellung.
# kubectl create deployment nginx --image=nginx
Überprüfen Sie, ob die Bereitstellung erstellt wurde.
# kubectl get deployments
Erstellen Sie einen Dienst.
# kubectl create service nodeport nginx --tcp=80:80
Ein Dienst kann unter Verwendung der folgenden Diensttypen erstellt werden: ClusterIP, NodePort, LoadBalance und ExternalName. Wenn der Typ „NodePort“ verwendet wird, wird für den Zugriff auf die bereitgestellten Dienste ein zufälliger Port aus dem Bereich 30000–32767 zugewiesen. Der an diesen Port gesendete Datenverkehr wird an den entsprechenden Dienst weitergeleitet.
Überprüfen Sie, ob der Dienst erstellt wurde und auf dem definierten Port lauscht.
# kubectl get svc
Merken Sie sich die Portnummer (in diesem Fall 31453).
Überprüfen Sie, ob Ihr Dienst bereitgestellt und verfügbar ist (der Befehl wird in diesem Beispiel auf dem Master-Knoten ausgeführt). Verwenden Sie den Hostnamen des Knotens und den Port, den Sie sich im vorherigen Schritt notiert haben.
# curl docker-nakivo31:31453
Sie können auch überprüfen, ob der Dienst im Browser eines beliebigen Knotens erreichbar ist. Versuchen Sie, in der Adressleiste des Webbrowsers die folgenden Seiten aufzurufen:
http:// 10.101.235.90
oder
http://docker-nakivo31:31453
http://docker-nakivo32:31453
Wenn alles in Ordnung ist, wird die nginx-Begrüßungsseite angezeigt.
Es ist außerdem möglich, die Nginx-Testseite von jedem Rechner aus aufzurufen, der Zugriff auf das Netzwerk hat, mit dem die Kubernetes-Knoten verbunden sind – in diesem Fall ( 192.168.101.0/24 ). Beispielsweise können Sie die folgenden Webseiten mit Ihrem Browser aufrufen:
http://192.168.101.21:31453/
http://192.168.101.31:31453/
http://192.168.101.32:31453/
Einrichten der Weboberfläche zur Überwachung von Kubernetes
Die Installation von Kubernetes unter Ubuntu ist fast abgeschlossen, Sie können jedoch für mehr Komfort auch das Kubernetes-Dashboard installieren. Das Kubernetes-Dashboard ist eine Weboberfläche zum Management und zur Überwachung von Kubernetes. Um das Dashboard zu installieren, erstellen Sie die Datei kubernetes-dashboard.yaml , ähnlich wie zuvor vor der Ausführung der Befehle.
# kubectl create -f ./kubernetes-dashboard.yaml
# kubectl apply -f ./kubernetes-dashboard.yaml
Pods überprüfen.
# kubectl get pods -o wide --all-namespaces
Starten Sie den Proxy zum Kubernetes-API-Server.
# kubectl proxy
Um die weiteren Befehle in die Konsole einzugeben, öffnen Sie bitte ein weiteres Konsolenfenster. Andernfalls würde der Prozess beendet werden.
Rufen Sie in Ihrem Webbrowser auf dem Master-Knoten die Seite auf:
http://localhost:8001
Sie sehen nun die Testseite.
Geben Sie die vollständige Adresse in die Adressleiste des Webbrowsers ein.
http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/
Erstellen Sie ein Dashboard mit einem Dienstkonto, indem Sie die Befehle im neuen Konsolenfenster ausführen.
# kubectl create serviceaccount dashboard -n default
# kubectl create clusterrolebinding dashboard-admin -n default
--clusterrole=cluster-admin
--serviceaccount=default:dashboard
# kubectl get secret $(kubectl get serviceaccount dashboard -o jsonpath="{.secrets[0].name}") -o jsonpath="{.data.token}" | base64 –decode
Nun können Sie das generierte Token sehen:
Kopieren Sie das generierte Token und fügen Sie es in den Token-Bereich der Weboberfläche ein, um sich beim Dashboard anzumelden.
Auf dem folgenden Screenshot sehen Sie die Weboberfläche des Kubernetes-Dashboards. Sie können den Status von Knoten, Bereitstellungen und Pods einsehen sowie Rollen, Speicherklassen und andere Komponenten überprüfen. 
Heapster, das Überwachungstool, einrichten
Installieren Sie Heapster, um die Überwachungsoptionen des Kubernetes-Dashboards um CPU-, Speicher- und andere Überwachungsparameter zu erweitern. Erstellen Sie eine Manifestdatei mit dem Namen heapster.yaml .
# vim heapster.yaml
Als nächsten Schritt stellen Sie Heapster bereit.
# kubectl create -f heapster.yaml
Bearbeiten Sie die RBAC-Rolle (Rollenbasierte Zugriffskontrolle) von Heapster und fügen Sie Berechtigungen für den Zugriff auf die Statistiken der Knoten hinzu.
# kubectl edit clusterrole system:heapster
Überprüfen Sie, ob CPU- und Speicher-Metriken in der Konsole gemessen werden können.
# kubectl top node
Nun können Sie die Weboberfläche des Kubernetes-Dashboards öffnen und sehen, dass einige Abschnitte, darunter Diagramme zur CPU- und Speicherauslastung, hinzugefügt wurden.
Ihr Kubernetes-Cluster ist nun konfiguriert und einsatzbereit.
Bereitstellung eines hochverfügbaren Kubernetes-Clusters mit mehreren Master-Knoten unter Ubuntu
Ein Kubernetes-Cluster mit einem Master-Knoten und einigen Worker-Knoten ist eine gute Option, doch manchmal kann der einzige Master-Knoten aus Gründen wie Hardwareproblemen oder Stromausfall ausfallen. Für eine höhere Fehlertoleranz des auf Ubuntu-Knoten bereitgestellten Kubernetes-Clusters empfiehlt es sich, die Bereitstellung eines hochverfügbaren Kubernetes-Clusters mit mehreren Master-Knoten in Betracht zu ziehen. Durch die Verwendung dieses Kubernetes-Cluster-Bereitstellungsmodells können Sie einen Single Point of Failure vermeiden. Es wird empfohlen, eine ungerade Anzahl von Master-Knoten zu verwenden; die Mindestanzahl an Master-Knoten, die Fehlertoleranz gewährleistet, beträgt drei. Wenn Sie mehr als drei Master-Knoten verwenden und die Anzahl der Knoten gerade ist, erhöht sich die Fehlertoleranz des gesamten Clusters nicht. In der folgenden Tabelle finden Sie einen Vergleich des Ausfallschutzes in Abhängigkeit von der Anzahl der Master-Knoten im Kubernetes-Cluster. Wenn Sie beispielsweise einen Cluster mit 5 Master-Knoten haben, kann der Cluster den Ausfall von 2 Master-Knoten überstehen, da drei Master-Knoten weiterhin arbeiten (3 von 5 sind mehr als 50 % und stellen die Mehrheit dar). Die Clustergröße bezieht sich auf die Anzahl der Master-Knoten im Cluster.
| Clustergröße | Mehrheit | Fehlertoleranz |
| 1 | 1 | 0 |
| 2 | 2 | 0 |
| 3 | 2 | 1 |
| 4 | 3 | 1 |
| 5 | 3 | 2 |
| 6 | 4 | 2 |
| 7 | 4 | 3 |
| 8 | 5 | 3 |
| 9 | 5 | 4 |
In diesem Abschnitt des heutigen Blogbeitrags wird erläutert, wie Kubernetes auf Ubuntu-Knoten im Rahmen der Bereitstellung eines Kubernetes-Hochverfügbarkeitsclusters, eines HA-Proxys und einiger Worker-Knoten installiert wird. In der folgenden Tabelle sehen Sie die IP-Adressen, Hostnamen und Rollen der Hosts, die für die Installation des HA-Kubernetes-Clusters auf Ubuntu-Knoten im in diesem Beispiel beschriebenen Testlabor verwendet werden.
| Nr. | Knotenrolle | IP-Adresse | Hostname |
| 1 | Master | 192.168.101.21 | docker-nakivo21 |
| 2 | Master | 192.168.101.22 | docker-nakivo22 |
| 3 | Master | 192.168.101.23 | docker-nakivo23 |
| 4 | HA Proxy | 192.168.101.19 | ha-proxy19 |
| 5 | Worker | 192.168.101.31 | docker-nakivo31 |
| 6 | Worker | 192.168.101.32 | docker-nakivo32 |
Einige Befehle sind dieselben wie bei der Installation von Kubernetes unter Ubuntu mit dem Modell mit einem Master-Knoten. Aus diesem Grund werden die Erläuterungen zu einigen Befehlen nicht wiederholt. Sie können auf dieser Seite nach oben scrollen, um die Erläuterungen zu den Befehlen noch einmal aufzurufen.
Bereiten Sie alle Maschinen (HA-Proxy, Master-Knoten und Worker-Knoten) für die Installation von Kubernetes wie folgt vor:
- Konfigurieren Sie statische IP-Adressen.
- Legen Sie Hostnamen fest. Die Namen aller Hosts müssen in IP-Adressen aufgelöst werden.
- Der SSH-Zugriff muss aktiviert und mithilfe von Zertifikaten konfiguriert werden.
- Der Swap-Speicher muss deaktiviert werden.
Diese Schritte müssen vor dem Start der Docker-Installation auf jedem Rechner durchgeführt werden – ganz ähnlich wie im obigen Abschnitt beschrieben, in dem die Installation von Kubernetes unter Ubuntu mit einem Master-Knoten erläutert wurde. Sobald Sie alle Maschinen vorbereitet haben, rufen Sie folgende Seiten auf: ( 192.168.101.19 ).
Konfiguration des HA-Proxy-Load-Balancers
Der HA-Proxy-Load-Balancer wird verwendet, um den eingehenden Datenverkehr auf die Kubernetes-Knoten zu verteilen. Der Load-Balancer wird vor den Master-Knoten bereitgestellt. Öffnen Sie die Konsole der ha-proxy19 Maschine und führen Sie die unten angegebenen Aktionen durch.
Installieren Sie cfssl
Cfssl (Cloud Flare SSL) ist ein Toolkit zur Erstellung verschiedener Zertifikate, einschließlich TLS/SSL-Zertifikatsketten.
Laden Sie die Binärdateien aus dem offiziellen Repository herunter.
# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
Machen Sie die heruntergeladenen Binärdateien ausführbar.
# chmod +x cfssl*
Verschieben Sie diese Binärdateien nach /usr/local/bin/
# mv cfssl_linux-amd64 /usr/local/bin/cfssl
# mv cfssljson_linux-amd64 /usr/local/bin/cfssljson
Überprüfen Sie die Installation, indem Sie die Version des installierten cfssl überprüfen.
# cfssl version
Aktualisieren Sie den Repository-Baum.
# apt-get update
Installieren Sie HA Proxy.
# apt-get install haproxy
Erstellen und bearbeiten Sie die Datei haproxy.cfg .
# vim /etc/haproxy/haproxy.cfg
Fügen Sie am Ende dieser Konfigurationsdatei die folgenden Zeilen hinzu.
frontend kubernetes
bind 192.168.101.19:6443
option tcplog
mode tcp
default_backend kubernetes-master-nodes
backend kubernetes-master-nodes
mode tcp
balance roundrobin
option tcp-check
server docker-nakivo21 192.168.101.21:6443 check fall 3 rise 2
server docker-nakivo22 192.168.101.22:6443 check fall 3 rise 2
server docker-nakivo23 192.168.101.23:6443 check fall 3 rise 2
Starten Sie den Dienst neu.
# systemctl restart haproxy
Erstellen Sie TSL-Zertifikate
Sie können die Konsole der HA Proxy-Maschine weiterhin verwenden. Erstellen Sie die Konfigurationsdatei der Zertifizierungsstelle, die ca-config.json genannt wird.
# vim ca-config.json
Fügen Sie der Konfigurationsdatei den folgenden Inhalt hinzu:
{
"signing": {
"default": {
"expiry": "8760h"
},
"profiles": {
"kubernetes": {
"usages": ["signing", "key encipherment", "server auth", "client auth"],
"expiry": "8760h"
}
}
}
}
Erstellen Sie die Anforderungsdatei für das Zertifikat.
# vim ca-csr.json
Fügen Sie der Datei den folgenden Inhalt hinzu:
{
„CN“: „Kubernetes“,
„key“: {
„algo“: „rsa“,
„Größe“: 2048
},
„Name“: [
{
„C“: „GB“,
„L“: „London“,
„O“: „Kubernetes“,
„OU“: „CA“,
„ST“: „Nakivo“
}
]
}
Hierbei gilt:
C – Land, zum Beispiel GB (Großbritannien).
L – Ort wie Stadt oder Ortschaft.
O – Organisation.
OU – Organisationseinheit (z. B. eine Abteilung, die als Schlüsselinhaber definiert ist).
ST – der Staat oder das Bundesland.
Generieren Sie nun den und den privaten Schlüssel.
# cfssl gencert -initca ca-csr.json | cfssljson -bare ca
Stellen Sie sicher, dass die ca-key.pem und die ca.pem Schlüssel erzeugt wurden.
# ls -al
Erstellung des Zertifikats für das etcd-Cluster
Etcd unterstützt die Kommunikation von Server zu Server/zu Cluster durch Authentifizierung mit Client-Zertifikaten. Sie sollten ein CA-Zertifikat und ein signiertes Schlüsselpaar für ein Cluster-Mitglied haben.
Erstellen Sie die Anforderungsdatei für das Zertifikat.
# vim kubernetes-csr.json
{
"CN": "kubernetes",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "GB",
"L": "London",
"O": "Kubernetes",
"OU": "Kubernetes",
"ST": "Nakivo"
}
]
}
Erstellen Sie anschließend das Zertifikat und den privaten Schlüssel.
# cfssl gencert
-ca=ca.pem
-ca-key=ca-key.pem
-config=ca-config.json
-hostname=192.168.101.21,192.168.101.22,192.168.101.23,192.168.101.19,127.0.0.1,kubernetes.default
-profile=kubernetes kubernetes-csr.json |
cfssljson -bare kubernetes
Listen Sie die Dateien in Ihrem Verzeichnis auf, um zu überprüfen, ob die kubernetes-key.pem und die kubernetes.pem Datei erzeugt wurden.
# ls -al
Kopieren Sie das erstellte Zertifikat auf jeden Knoten. # scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.21:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.22:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.23:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.31:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.32:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.33:~
Dabei ist ~ das Home-Verzeichnis von kubernetes-user auf Ubuntu-Hosts.
Vorbereitung der Ubuntu-Knoten für die Installation von Kubernetes
Führen Sie die in diesem Abschnitt aufgeführten Befehle auf allen Master- und Worker-Knoten aus. Installieren Sie Docker und anschließend Kubernetes auf den Ubuntu-Rechnern, die in den Kubernetes-Cluster aufgenommen werden sollen. Beginnen wir mit der Vorbereitung des 192.168.101.21 Master-Knoten.
Installieren Sie Docker.
# apt-get install apt-transport-https ca-certificates curl software-properties-common
# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
# add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
# apt-get update
# apt-get install docker-ce
Docker ist nun installiert. Cubeadm, kublet und cubectl sind die Kubernetes-Komponenten, die für die Installation von Kubernetes unter Ubuntu erforderlich sind.
Installieren Sie die Kubernetes-Komponenten – kubeadm, kubelet und kubectl.
# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
# echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.list
# apt-get update
# apt-get install -y kubelet kubeadm kubectl
Nachdem Sie alle Knoten vorbereitet und Docker, kubelet, kubeadm sowie kubectl installiert haben, müssen Sie etcd auf den Master-Knoten installieren und konfigurieren.
Installation und Konfiguration von etcd auf Ubuntu-Master-Knoten
Etcd ist ein konsistenter und hochverfügbarer Datenspeicher, der sowohl zum Speichern von Schlüsseln als auch zum Sichern aller Clusterdaten dient. Der etcd-Cluster muss eingerichtet werden, bevor der HA-Kubernetes-Cluster mit mehreren Master-Knoten konfiguriert wird. Beginnen wir mit der Konfiguration des 192.168.101.21 Master-Knotens.
Installing and configuring etcd on the 192.168.101.21 machine.
Erstellen Sie ein Konfigurationsverzeichnis für etcd.
# mkdir /etc/etcd /var/lib/etcd
Wechseln Sie in das Verzeichnis, in das die Zertifikate kopiert wurden. Dies ist das Home-Verzeichnis des Benutzers „kubernetes“, in diesem Fall: /home/kubernetes-user/
Kopieren Sie die Zertifikate in das etcd-Konfigurationsverzeichnis.
# cp ca.pem kubernetes.pem kubernetes-key.pem /etc/etcd
Überprüfen Sie, ob die Dateien kopiert wurden.
# ls -al /etc/etcd
Kehren Sie zum vorherigen Verzeichnis zurück.
# cd -
Herunterladen Sie die etcd-Binärdateien aus dem Repository.
# wget https://github.com/coreos/etcd/releases/download/v3.3.9/etcd-v3.3.9-linux-amd64.tar.gz
Entpacken Sie das etcd-Archiv.
# tar xvzf etcd-v3.3.9-linux-amd64.tar.gz
Verschieben Sie nun die etcd-Binärdateien nach /usr/local/bin/
# mv etcd-v3.3.9-linux-amd64/etcd* /usr/local/bin/
Erstellen Sie eine etcd-systemd-Unit-Datei.
# vim /etc/systemd/system/etcd.service
Fügen Sie die unten aufgeführten Zeichenfolgen in diese Datei ein.
[Unit]
Description=etcd
Documentation=https://github.com/coreos
[Service]
ExecStart=/usr/local/bin/etcd
--name 192.168.101.21
--cert-file=/etc/etcd/kubernetes.pem
--key-file=/etc/etcd/kubernetes-key.pem
--peer-cert-file=/etc/etcd/kubernetes.pem
--peer-key-file=/etc/etcd/kubernetes-key.pem
--trusted-ca-file=/etc/etcd/ca.pem
--peer-trusted-ca-file=/etc/etcd/ca.pem
--peer-client-cert-auth
--client-cert-auth
--initial-advertise-peer-urls https://192.168.101.21:2380
--listen-peer-urls https://192.168.101.21:2380
--listen-client-urls https://192.168.101.21:2379,http://127.0.0.1:2379
--advertise-client-urls https://192.168.101.21:2379
--initial-cluster-token etcd-cluster-0
--initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380
--initial-cluster-state new
--data-dir=/var/lib/etcd
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
Laden Sie die Konfiguration des systemd-Managers neu, um geänderte Konfigurationen aus dem Dateisystem zu übernehmen und Abhängigkeitsbäume neu zu generieren.
# systemctl daemon-reload
Stellen Sie sicher, dass etcd beim Systemstart begonnen wird.
# systemctl enable etcd
Starten Sie etcd. # systemctl start etcd
Führen Sie dieselben Aktionen auf dem zweiten Masterknoten aus ( docker-nakivo22 – 192.168.101.21 und docker-nakivo23 – 192.168.101.22 ). Der einzige Unterschied bei den Aktionen für diese Masterknoten besteht im Bearbeiten der etcd.service -Konfigurationsdatei. Definieren Sie die korrekten IP-Adressen für die jeweiligen anderen Masterknoten. Zum Beispiel muss die etcd.service -Konfigurationsdatei für den zweiten Masterknoten ( 192.168.101.22 ) des aktuellen Kubernetes-Testlabors folgendermaßen aussehen.
[Unit]
Description=etcd
Documentation=https://github.com/coreos
[Service]
ExecStart=/usr/local/bin/etcd
--name 192.168.101.22
--cert-file=/etc/etcd/kubernetes.pem
--key-file=/etc/etcd/kubernetes-key.pem
--peer-cert-file=/etc/etcd/kubernetes.pem
--peer-key-file=/etc/etcd/kubernetes-key.pem
--trusted-ca-file=/etc/etcd/ca.pem
--peer-trusted-ca-file=/etc/etcd/ca.pem
--peer-client-cert-auth
--client-cert-auth
--initial-advertise-peer-urls https://192.168.101.22:2380
--listen-peer-urls https://192.168.101.22:2380
--listen-client-urls https://192.168.101.22:2379,http://127.0.0.1:2379
--advertise-client-urls https://192.168.101.22:2379
--initial-cluster-token etcd-cluster-0
--initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380
--initial-cluster-state new
--data-dir=/var/lib/etcd
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
Initialisierung der Masterknoten im Kubernetes HA-Cluster
Jetzt können Sie die Masterknoten in Ihrem Kubernetes HA-Cluster initialisieren, der auf Ubuntu-Maschinen installiert ist.
Initialisierung des 192.168.101.21-Masterknotens
Führen Sie auf dem ersten Masterknoten den im Folgenden erläuterten Umfang der Operationen aus.
Erstellen Sie die YAML-Konfigurationsdatei für Kubeadm.
# vim config.yaml
Fügen Sie die Konfigurationsparameter zu dieser Datei hinzu:
apiVersion: kubeadm.k8s.io/v1alpha3
kind: ClusterConfiguration
kubernetesVersion: stable
apiServerCertSANs:
- 192.168.101.19
controlPlaneEndpoint: "192.168.101.19:6443"
etcd:
external:
endpoints:
- https://192.168.101.21:2379
- https://192.168.101.22:2379
- https://192.168.101.23:2379
caFile: /etc/etcd/ca.pem
certFile: /etc/etcd/kubernetes.pem
keyFile: /etc/etcd/kubernetes-key.pem
networking:
podSubnet: 10.244.0.0/16
apiServerExtraArgs:
apiserver-count: "3"
Das als PodSubnet definierte Netzwerk (10.244.0.0/16) muss mit dem in der kube-flannel.yml -Datei identisch sein.
Initialisieren Sie die Ubuntu-Maschine als Masterknoten.
# kubeadm init --config=config.yaml
Manchmal kann eine Warnung bezüglich der alten Version einer Konfigurationsdatei angezeigt werden:
Ihre Konfigurationsdatei verwendet eine veraltete API-Spezifikation: „kubeadm.k8s.io/v1alpha3“. Bitte verwenden Sie ‚kubeadm config migrate –old-config old.yaml –new-config new.yaml‘, um eine neue, ähnlich spezifizierte Datei mit einer neueren API-Version zu schreiben.
Aktualisieren Sie die Version der Konfigurationsdatei mit dem Befehl:
# kubeadm config migrate --old-config config.yaml --new-config config1.yaml
Ein weiterer Fehler kann auftreten, wenn Sie einen Knoten eines Multi-Master-Kubernetes-Clusters initialisieren, wenn etcd nicht ausgeführt wird:
[ERROR ExternalEtcdVersion]: Get https://192.168.101.21:2379/version: dial tcp 192.168.101.21:2379: connect: Verbindung abgelehnt
Prüfen Sie, ob Ihr etcd läuft. Sie können etcd manuell ausführen:
# systemctl start etcd
Nach erfolgreicher Initialisierung des Masterknotens im unter Ubuntu laufenden Kubernetes-Cluster erhalten Sie die folgende Nachricht, wie auf dem Screenshot angezeigt. 
Die Ausgabe nach erfolgreicher Ausführung dieses Befehls enthält einen Hinweis dazu, wie Sie Ihren Cluster in Betrieb nehmen können, sowie Befehle, die ein Token und einen Zertifikats-Hash enthalten, die für die Einbindung von Knoten in den Cluster erforderlich sind. Speichern Sie diese wichtigen Zeichenfolgen, da Sie sie bald benötigen werden. Sie sind auf dem Screenshot gelb markiert und werden im Folgenden wiedergegeben.
Sie können nun beliebig viele Control-Plane-Knoten hinzufügen, indem Sie die Zertifizierungsstellen
und die Schlüssel der Dienstkonten auf jeden Knoten kopieren und anschließend als Root Folgendes ausführen:
kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
--experimental-control-plane
Anschließend können Sie beliebig viele Worker-Knoten hinzufügen, indem Sie auf jedem Knoten als Root Folgendes ausführen:
kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
Führen Sie die folgenden Befehle aus, um den initialisierten Knoten im Cluster zu nutzen.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Überprüfen Sie die dem Cluster hinzugefügten Knoten.
# kubectl get nodes
Kopieren Sie die Zertifikate auf die beiden anderen Master-Knoten
# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.22:~
# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.23:~
Initialisierung des Master-Knotens 192.168.101.22
Führen Sie die Befehle auf dem zweiten Master-Knoten (192.168.101.22) aus.
Entfernen Sie die Dateien apiserver.crt und apiserver.key , die sich im Home-Verzeichnis (~) des Benutzers kubernetes-user befinden.
$ rm ~/pki/apiserver.*
Verschieben Sie die im Home-Verzeichnis gespeicherten Zertifikate in das Verzeichnis /etc/kubernetes/ .
$ sudo mv ~/pki /etc/kubernetes/
Erstellen Sie die YAML-Konfigurationsdatei für kubeadm.
# vim config.yaml
Der Inhalt dieser YAML-Datei entspricht dem des ersten Master-Knotens ( 192.168.101.21 ). Siehe die oben angegebene Konfiguration für die Initialisierung des ersten Master-Knotens. Sie können die bereits erstellte Datei kopieren, die auf dem ersten Master-Knoten des auf Ihren Ubuntu-Rechnern installierten Kubernetes-HA-Clusters verwendet wird.
Initialisieren Sie den zweiten Master-Knoten.
# kubeadm config migrate --old-config config.yaml --new-config config1.yaml
# kubeadm init --config=config1.yaml
Die Ausgabe entspricht der Anzeige, die nach der Initialisierung des ersten Master-Knotens im Kubernetes-HA-Cluster angezeigt wurde:
Führen Sie ebenfalls die Befehle aus, um den initialisierten Knoten im Cluster in Betrieb zu nehmen.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Überprüfen Sie die dem Cluster hinzugefügten Knoten.
# kubectl get nodes
Zwei von drei Master-Knoten wurden dem Cluster hinzugefügt. Ein Master-Knoten muss noch hinzugefügt werden.
Initialisierung des dritten Master-Knotens (192.168.101.23)
Wiederholen Sie die gleichen Schritte wie bei der Initialisierung des zweiten Knotens (192.168.101.22) im Cluster. Vergessen Sie nicht, sich die Befehle mit Token und Hashes zum Hinzufügen von Knoten zum Cluster zu notieren, die nach der Initialisierung der Master-Knoten angezeigt werden.
Überprüfen Sie, ob alle drei Master-Knoten erfolgreich zum Cluster hinzugefügt wurden.
# kubectl get nodes
Installation von Flannel zur Behebung des „NotReady“-Status von Master-Knoten in Kubernetes
Installieren wir nun Flannel. Im Gegensatz zum ersten Beispiel, in dem Sie gelernt haben, wie man Kubernetes unter Ubuntu installiert, um einen Cluster mit einem einzigen Master zu erstellen, wird Flannel in diesem Beispiel mithilfe der YAML-Datei installiert.
Führen Sie den Befehl aus, um Flannel zu installieren und den „NotReady“-Status der Knoten zu beheben, der angezeigt wird, da noch kein Overlay-Netzwerk konfiguriert ist. Erstellen Sie die kube-flannel.yaml Datei beispielsweise mit dem Texteditor vim auf dem ersten Master-Knoten.
# kubectl apply -f kube-flannel.yml
Merken Sie sich die Adresse des podSubnet, das in der Datei config.yaml definiert ist. Die Netzwerkadresse muss in der Datei kube-flannel.yaml übereinstimmen.
Überprüfen Sie Ihre Knoten und ihren Status.
# kubectl get nodes
Nun arbeiten alle Master-Knoten einwandfrei.
Hinzufügen von Worker-Knoten zum Cluster
Sobald Sie alle Master-Knoten initialisiert haben, können Sie Ihrem Kubernetes-Cluster Worker-Knoten hinzufügen. Fügen wir den ersten Worker-Knoten ( 192.168.101.31 ) zum HA-Kubernetes-Cluster hinzu, der auf Ubuntu-Rechnern bereitgestellt wurde. Verwenden Sie den Befehl, der nach der Initialisierung der Master-Knoten angezeigt wurde (der Befehl, der das Token und den Hash enthält), um den Worker-Knoten dem Cluster beitreten zu lassen. Führen Sie den Befehl auf dem 192.168.101.31 Rechner aus.
# kubeadm join 192.168.101.19:6443 --token kxl1gf.6ddalutd60n0ez45
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
Überprüfen Sie die Knoten des Kubernetes-HA-Clusters, um sicherzustellen, dass der Worker-Knoten hinzugefügt wurde. Sie können nun auch den HA-Proxy-Rechner in der Liste der Knoten sehen.
# kubectl get nodes
Fügen Sie auf dieselbe Weise weitere Worker-Knoten zum Kubernetes-High-Availability-Cluster hinzu, der auf Ubuntu-Rechnern installiert ist. Je nach Bedarf können Sie jederzeit weitere Worker-Knoten hinzufügen. Damit stellen Sie das heutige Tutorial fertig.
Fazit
Die Installation von Kubernetes unter Ubuntu ist nicht so schwierig, wie es auf den ersten Blick erscheinen mag. Die Bereitstellung eines Kubernetes-Clusters erfordert zwar einigen Aufwand, bietet Ihnen aber im Gegenzug zahlreiche Vorteile wie ein zentralisiertes, vereinfachtes Management, hohe Skalierbarkeit und Lastenausgleich. Die einfachste Art der Kubernetes-Bereitstellung ist eine Ein-Master-Bereitstellung – Sie sollten Kubernetes auf Ubuntu-Knoten installieren, darunter sowohl Master- als auch Worker-Knoten. Wenn Sie eine zuverlässigere Infrastruktur für den Betrieb containerisierter Anwendungen benötigen, sollten Sie die Bereitstellung eines Multi-Master-Kubernetes-Clusters in Betracht ziehen, der als „Kubernetes High Availability Cluster“ bezeichnet wird. Diese Art der Kubernetes-Bereitstellung verhindert einen Single Point of Failure, und Ihr Cluster bleibt auch dann funktionsfähig, wenn einige der Master-Knoten ausfallen.
Bei beiden Bereitstellungsarten müssen Sie den SSH-Zugriff konfigurieren, statische IP-Adressen und Hostnamen festlegen, Docker installieren, die Verwendung einer Swap-Partition deaktivieren und schließlich Kubernetes-Komponenten wie kubeadm, kubectl und kubelet installieren sowie Flannel für das Overlay-Netzwerk konfigurieren. Bei der Bereitstellung des HA-Kubernetes-Clusters müssen Sie außerdem den HA-Proxy auf einem eigenständigen Rechner konfigurieren, Zertifikate generieren und den etcd-Cluster einrichten. Die meisten Schritte bei der Konfiguration von Kubernetes, der Erstellung von Bereitstellungen sowie der Ausführung von Pods lassen sich auf zwei Arten durchführen: durch manuelle Ausführung der von der Befehlszeilenschnittstelle bereitgestellten Befehle und durch die Verwendung von YAML-Konfigurationsdateien. Die Verwendung von YAML-Dateien ermöglicht es Ihnen, komplexere Strukturen zu erstellen, und erleichtert die Verwaltung.
Sie können Kubernetes unter Ubuntu installieren, sowohl auf physischen als auch auf virtuellen Maschinen. Wenn Ihr Kubernetes auf virtuellen Maschinen installiert ist, die unter vSphere laufen, können Sie zusätzlichen Schutz durch die Verwendung von VMware-Hochverfügbarkeitscluster mit der Fault-Tolerance-Funktion gewährleisten. Die in diesem Blogbeitrag behandelten Grundlagen der Kubernetes-Bereitstellung lassen sich auch für die Installation von Kubernetes auf anderen Linux-Distributionen nutzen.
