So installieren Sie Kubernetes unter Ubuntu

Die manuelle Bereitstellung von Docker-Containern auf mehreren Servern kann sehr zeitaufwändig sein und den Plan jedes Systemadministrators, der mit dieser Aufgabe betraut ist, vollständig auslasten. In der modernen IT-Branche wächst die Beliebtheit von Clouds, Microservices und Containern weiter, weshalb Lösungen wie Kubernetes entwickelt wurden.Kubernetes ist eine Open-Source-Lösung für das Container-Management und die Orchestrierung, 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. Das Ziel dieses Blogbeitrags ist es, zu untersuchen, wie Kubernetes auf Ubuntu installiert werden kann, um Anwendungen in Docker-Containern auszuführen.

NAKIVO for VMware vSphere Backup

Complete data protection for VMware vSphere VMs and instant recovery options. Secure backup targets onsite, offsite and in the cloud. Anti-ransomware features.

DISCOVER SOLUTION

Anforderungen und Systemkonfiguration für die Installation von Kubernetes auf 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 Mindesthardwareanforderungen für die Installation von Kubernetes unter Ubuntu sind:

• Mindestens eine 2-Kern-x86/x64-CPU (Zentraleinheit)
• 2 GB RAM (Arbeitsspeicher) oder mehr
• Internetzugang

Ports, die für die Installation von Kubernetes unter Ubuntu geöffnet werden müssen:

Standardmäßig ist die iptables-Firewall auf Ubuntu installiert, aber es gibt keine vordefinierten Blockierungsregeln. Wenn Sie also Ubuntu installieren, um Kubernetes auszuprobieren, müssen Sie die Firewall-Regeln nicht bearbeiten. Kube-proxy platziert zunächst seine iptables-Ketten und fügt dann zwei iptables-Regeln ein. Diese Regeln sind KUBE-EXTERNAL-SERVICES und KUBE-FIREWALL, die am Anfang der INPUT-Kette eingefügt werden.Die Installation von Kubernetes auf Ubuntu kann sowohl auf physischen als auch auf virtuellen Maschinen erfolgen. Generell wird empfohlen, die neueste Version von 64-Bit-Ubuntu-Linux zu verwenden. Der heutige Blogbeitrag erklärt die Installation von Kubernetes auf Ubuntu 18.04 LTS, das auf VMware-VMs läuft. Der erste erklärte Kubernetes-Bereitstellungstyp ist mit einem Master-Knoten, und zwei Worker-Knoten werden für den Kubernetes-Cluster verwendet. In der folgenden Tabelle finden Sie die bedingte Anzahl von Knoten, Knotenrollen, Hostnamen und IP-Adressen der Maschinen, die in dem betrachteten Beispiel verwendet werden.

Sie können VMs verwenden, die auf ESXi-Hosts laufen, wenn Sie VMware vSphere verwenden, oder Sie können VMs auf VMware Workstation ausführen, das auf Ihrem PC mit Linux oder Windows installiert ist. In unserem heutigen Beispiel verwenden wir VMs, die auf VMware Workstation laufen. VMs verwenden NAT. Netzwerk mit Internetzugang, und wenn Sie es vorziehen VirtualBox zu VMware, können Sie es verwenden.Die IP-Adresse des Host-Rechners: 10.10.10.53Die IP-Adresse des virtuellen Gateways für das NAT-Netzwerk (VMNet8): 192.168.101.2Der gleiche Linux-Benutzer existiert auf allen Ubuntu-Rechnern: Kubernetes-BenutzerVM-Konfiguration: 2 CPU, 4 GB RAM, 20 GB virtuelle FestplatteSie können die IP-Adressen von VMnet8 ändern, indem Sie zu Edit > Virtual Network Editor in VMware Arbeitsstation.Zum besseren Verständnis werden alle Komponenten heute manuell unter Linux installiert, ohne Automatisierungstools wie Ansible.

Bereitstellung der Ubuntu-VM

Erstellen Sie eine neue VM mit dem Namen is. Docker-Nakivo21.Installieren Sie Ubuntu 64-Bit auf dem ersten Rechner und legen Sie den Hostnamen und Benutzername fest.VM-Name: Docker-Nakivo21Benutzername: Kubernetes-BenutzerInstallieren Sie VMware Tools nach der ersten Anmeldung beim installierten Betriebssystem. Wenn Sie physische Maschinen verwenden, benötigen Sie VMware Tools nicht und können diesen Schritt überspringen.Hinweis: Das $ Das Zeichen am Anfang bedeutet, dass ein Befehl als normaler Benutzer ausgeführt wird (Kubernetes-Benutzer in diesem Fall). Wenn die Zeichenfolge mit dem # Zeichen muss der Befehl wie folgt ausgeführt werden: Wurzel. Das sudo Mit dem Befehl (substitute user do oder Superuser do) können Sie Befehle als anderer Benutzer, einschließlich Root-Benutzer, ausführen. Sie können Folgendes eingeben: sudo -i um die Root-Rechte in der Konsole zu erhalten. Drücken Sie Strg+D, um den Root-Modus zu verlassen.Sie können VMware Tools aus dem mit dem VMware-Hypervisor mitgelieferten ISO-Image oder aus Linux-Repositorys (siehe unten) installieren.$ sudo apt-get install open-vm-toolsWenn Sie erweiterte Desktop-Funktionen wie eine gemeinsame Zwischenablage oder Drag & Drop benötigen, die Daten teilen, & Dateien ablegen usw., ausführen:$ sudo apt-get install open-vm-tools-desktopStarten Sie die VM neu.$ init 6

Konfigurieren Sie Ihren Ubuntu-Rechner vor der Installation von Kubernetes

Vor der Installation von Kubernetes auf Ubuntu-Rechnern müssen einige Vorbereitungen getroffen werden. Zunächst müssen Sie die statische IP-Adresse und den Host-Name für jeden üblichen Server konfigurieren.

Statische IP-Adresse festlegen

Wie bei jeder anderen Art von Cluster wird die Verwendung statischer IP-Adressen auf den Knoten dringend empfohlen.Installieren Sie die Linux-Netzwerktools, bevor Sie die IP-Adresse festlegen.$ sudo apt-get install net-toolsTyp ifconfig um die aktuelle IP-Adresse Ihrer Ubuntu-VM zu überprüfen.Sie können sehen, dass die IP-Adresse automatisch über DHCP bezogen wird. Merken Sie sich den Namen der Netzwerkschnittstelle. Im aktuellen Beispiel lautet dieser Name ens33Der Name der ersten Ethernet-Netzwerkschnittstelle lautet in der Regel eth0 für physische Maschinen.Sie benötigen einen Texteditor zum Bearbeiten von Konfigurationsdateien. Installieren Sie vim als Texteditor.$ sudo apt-get install vimIn den neuesten Ubuntu-Versionen wird die Netzwerkkonfiguration in der YAML-Datei festgelegt. Öffnen Sie die YAML-Datei für die Netzwerkkonfiguration in vim.$ sudo vim /etc/netplan/01-network-manager-all.yamlDie Standardansicht der Konfigurationsdatei lautet: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 tryDrücken Sie die Eingabetaste, um die neue Konfiguration zu übernehmen.Überprüfen Sie, ob sich Ihre Netzwerkkonfiguration geändert hat, und versuchen Sie beispielsweise einen Ping. nakivo.com.$ ifconfig$ ping nakivo.com

Hostnamen konfigurieren

Überprüfen Sie Ihren aktuellen Hostnamen.$ hostnamectlWie Sie sich erinnern, lautet der Hostname für die erste VM, die Docker-Nakivo21 wurde bereits während der Installation konfiguriert. Um den Hostnamen zu ändern, gehen Sie wie folgt vor (dies ist für die Konfiguration der zweiten und dritten VMs nach dem Klonen erforderlich. Diese beiden VMs sollen als Worker-Knoten konfiguriert werden):Wenn Sie beispielsweise den Hostnamen in Docker-Nakivo21 Führen Sie auf der ersten VM Folgendes aus:$ sudo hostnamectl set-hostname docker-nakivo21Überprüfen Sie, ob ein neuer Hostname angewendet wurde.$ less /etc/hostnameBearbeiten Sie die Host Datei.$ sudo vim /etc/hostsDer Inhalt der Hostdatei muss wie folgt aussehen:127.0.0.1 localhost127.0.1.1 docker-nakivo21Starten Sie den Rechner neu.$ init 6

Swap-Dateien deaktivieren

Die Verwendung einer Auslagerungsdatei (Swap-Partition) wird von Kubernetes nicht unterstützt. Um Kubernetes erfolgreich auf Ubuntu zu installieren, muss die Swappiness deaktiviert werden.Deaktivieren Sie eine Auslagerungsdatei, um eine hohe CPU-Auslastung durch Kubelet zu verhindern.$ sudo swapoff -aBearbeiten /etc/fstab und kommentieren Sie die Zeichenfolge von dem # Charakter.$ sudo vim /etc/fstab#/swapfile Keine Swap sw 0 0Das Gleiche können Sie auch mit sed mit nur einem einzigen Befehl:$ sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstabSwap deaktivieren in sysctl.conf$ sudo echo \"vm.swappiness=0\" | sudo tee --append /etc/sysctl.confWobei 0 der Prozentsatz der Swapiness ist. In diesem Fall kann Swap nur verwendet werden, wenn Sie keinen RAM mehr haben (standardmäßig wird Swap verwendet, wenn mehr als 60 % des RAM belegt sind).Konfigurationsänderungen ohne Neustart anwenden.$ sudo sysctl -pHinweisWenn die Swap-Partition nicht deaktiviert ist, wird die kswapd0 Der Prozess von Ubuntu Linux mit Kubernetes kann eine große Menge an CPU-Ressourcen auf Ihrem Rechner verbrauchen, wodurch Anwendungen nicht mehr reagieren und das System hängen bleibt. Dies geschieht, wenn dem Betriebssystem der Arbeitsspeicher ausgeht und die alten Speicherseiten von einem Linux-Kernel-Systemprozess in den Swap-Bereich verschoben werden. Aus seltsamen Gründen kommt es manchmal zu Fehlern, und es entsteht eine Endlosschleife, die alle CPU-Ressourcen verbraucht. Auf dem Screenshot unten sehen Sie einen hohen CPU-Verbrauch durch den kswapd0 Prozess, wenn Kubernetes auf Ubuntu installiert ist. Der durchschnittliche Auslastungswert ist übermäßig hoch.Wenn kswapd0 Wenn Ihre CPU immer noch überlastet ist, führen Sie den folgenden Befehl aus, um alle Speicher-Caches zu invalidieren und zu stoppen: kswapd0 (als Root ausführen).# echo 1 > /proc/sys/vm/drop_cachesSchalten Sie die VM aus.$ init 0Diese teilweise konfigurierte Virtuelle Maschine (Docker-Nakivo21) soll als Master-Knoten verwendet werden. Erstellen Sie zwei Maschinen, die als Worker-Knoten verwendet werden sollen. Wenn Sie physische Maschinen verwenden, wiederholen Sie die vorherigen Schritte manuell (oder verwenden 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 Zeit bei der Vorbereitung der Umgebung für die Installation von Kubernetes auf Ubuntu-Maschinen zu sparen.

Die VM klonen

Klonen Sie Ihre erste VM. Wenn Sie VMware ESXi verwenden, können Sie die integrierte Klon-Funktion nutzen. Mehr über dieses Thema erfahren Sie in unserem Blogbeitrag unter Klonen von VMs mithilfe von VM-VorlagenWenn Sie VMware Workstation verwenden, können Sie VMs auch mit zwei Methoden klonen (integriertes Klon-Tool und manuell). Sie können klicken auf VM > Manage > Clone um einen verknüpften Klon zu erstellen. Erstellen wir einen vollständigen Klon der ersten VM und kopieren wir die VM-Dateien manuell. In diesem Fall werden die Dateien aus dem Docker-Nakivo21 Verzeichnis zu Docker-Nakivo31. Die Verzeichnisse müssen vor dem Kopieren der VM-Dateien manuell erstellt werden.Bearbeiten Sie die VMX-Datei, da der VM-Name und der Pfad zur virtuellen Festplattendatei geändert wurden.displayName = \"docker-nakivo31\"scsi0:0.fileName = \"C:\Virtual\KUBERNETES\docker-nakivo31\docker-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 zuvor beschrieben.displayName = \"docker-nakivo32\"scsi0:0.fileName = \"C:\Virtual\KUBERNETES\docker-nakivo31\docker-nakivo32.vmdk\"nvram = \"docker-nakivo32.nvram\"Öffnen Sie die VM-Klone in VMware Workstation (File> Open und wählen Sie die VMX-Datei der Virtuellen Maschine aus) oder doppelklicken Sie einfach auf die VMX-Datei der Virtuellen Maschine. Starten Sie drei Virtuelle Maschinen (Ihre eine Quelle-VM und zwei VM-Klone). Klicken Sie auf Ich habe es kopiert., wenn Sie dazu aufgefordert werden.HinweisWenn 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 Host-Namen 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 beschriebenen Schritte, um die statischen IP-Adressen und Hostnamen zu konfigurieren.Die IP-Adresse muss lauten: 192.168.101.31 und 192.168.101.32; die Hostnamen müssen Docker-Nakivo31 und Docker-Nakivo32 entsprechend auf den Worker-Knoten.Alle Maschinen müssen so konfiguriert sein, dass sie die Hostnamen der Knoten in IP-Adressen auflösen. Sie können einen DNS-Server konfigurieren oder die Datei „hosts“ bearbeiten. Host Dateien auf jedem Rechner. Bearbeiten wir Hosts.Fügen Sie die folgenden Zeichenfolgen zum Hosts Dateien auf jedem Rechner (Docker-Nakivo21, Docker-Nakivo31, Docker-Nakivo32).$ sudo vim /etc/hostsFügen Sie diese Zeilen zum Hosts Datei:192.168.101.21 docker-nakivo21192.168.101.31 docker-nakivo31192.168.101.32 docker-nakivo32Pingen 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

SSH-Zugriff auf allen Hosts (VMs) konfigurieren

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-serverGehen Sie zum Home-Verzeichnis von Kubernetes-Benutzer und generieren Sie das SSH-Schlüsselpaar (ein Satz kryptografischer Schlüssel, der aus einem privaten Schlüssel und einem öffentlichen Schlüssel besteht). SSH-Schlüsselpaare können verwendet werden, um über SSH ohne Passwörter auf die Remote-Linux-Konsole zuzugreifen. Der öffentliche Schlüssel kann auf einen Rechner kopiert werden, von dem aus Sie eine Remote-Verbindung herstellen möchten, während der private Schlüssel streng geheim ist und auf dem Rechner gespeichert werden muss, mit dem Sie eine Verbindung herstellen möchten.$ ssh-keygenEs ist nicht erforderlich, das Passwort für die Schlüsselgenerierung einzugeben (das Passwort ist optional).Kopieren Sie die Schlüssel auf andere Ubuntu-Rechner:$ ssh-copy-id kubernetes-user@192.168.101.31$ ssh-copy-id kubernetes-user@192.168.101.32Geben Sie Ihr Passwort ein, um das Kopieren der Schlüssel zu bestätigen.Versuchen Sie, sich mit dem zweiten Rechner zu verbinden (Docker-Nakivo31) als Kubernetes-Benutzer (das ist ein regulärer Benutzer).$ ssh 'kubernetes-user@192.168.101.31'Dann die Verbindung zum dritten Rechner testen (Docker-Nakivo32).$ ssh 'kubernetes-user@192.168.101.32'Nach erfolgreichem Verbinden wird der Name des Remote-Computers in der Eingabeaufforderung Ihrer Konsole angezeigt.Drücken Sie Strg+D, um die Remote-Konsole zu verlassen.

Wie kopiere ich den Schlüssel zum Verbinden über SSH als Root-Benutzer?

Da Sie in Kubernetes Root-Rechte benötigen, erstellen wir nun Schlüssel für die Konfiguration des SSH-Zugriffs für Root. Führen Sie die folgenden Befehle auf allen Maschinen (docker-nakivo21, docker-nakivo31 und docker-nakivo32) aus, auf die als Root-Benutzer über SSH zugegriffen werden muss.$ sudo -iBearbeiten Sie die Konfigurationsdatei des SSH-Servers.# vim /etc/ssh/sshd_configFügen Sie die folgende Zeichenfolge zu dieser Datei hinzu bzw. bearbeiten Sie sie.PermitRootLogin yesStarten Sie den SSH-Server-Daemon neu.# /etc/init.d/ssh stop# /etc/init.d/ssh startLegen Sie das Root-Passwort (Passwort für den Root-Benutzer) fest.# passwd$ cd /home/kubernetes-user/$ sudo ssh-keygen -t rsaKopieren Sie den öffentlichen Schlüssel, um sich per SSH als Root-Benutzer remote anmelden zu können (der Schlüssel wird im Home-Verzeichnis des regulären Benutzers gespeichert, 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.1Wenn 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.1Bestätigen Sie diesen Vorgang und geben Sie Ihr Passwort ein.Wiederholen Sie diesen Vorgang und kopieren Sie den Schlüssel von jedem Rechner auf die anderen Rechner. Beispielsweise auf dem Docker-Nakivo21 Maschine ausführen:# 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.32Autorisieren Sie den öffentlichen Schlüssel.# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keysÜberprüfen Sie, ob Sie sich über SSH auf dem lokalen Rechner als root anmelden können.$ sudo ssh root@127.0.0.1Versuchen Sie, sich vom/zum Remote-Rechner zu verbinden, ohne ein Passwort einzugeben.$ sudo ssh root@192.168.101.21$ sudo ssh root@192.168.101.31$ sudo ssh root@192.168.101.32Hinweis: Das Verbinden als Root-Benutzer kann unsicher sein. Stellen Sie keine Verbindung als Root-Benutzer her, wenn dies nicht erforderlich ist. Es ist besser, sich über SSH als normaler Benutzer zu verbinden und den Befehl sudo Befehl.

Docker-Installation

Docker ist die beliebteste Plattform für Container für Unternehmensanwendungen, die von Kubernetes unterstützt wird. Installieren Sie Docker auf allen Rechnern. Führen Sie die folgenden Befehle aus auf Docker-Nakivo21, Docker-Nakivo31, Docker-Nakivo32Sie müssen sich jedoch nicht beeilen. Für einen ersten Blick können Sie Docker einfach von dem üblichen Befehl installieren:$ sudo apt-get install -y docker.ioIn diesem Fall ist die verwendete Docker-Version jedoch 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-commonCurl ist ein universelles Kompakt-Tool, das für die Übertragung von Daten von/zu einem Host ohne Benutzerinteraktion unter Verwendung eines der unterstützten Protokolle (HTTP, HTTPS, FTP, FTPS, SFTP, LDAP, LDAPS, IMAP, IMAPS, POP3, POP3S, SCP, SMB, SMTP, TELNET usw.) entwickelt wurde.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 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 Ihre Datenbank des Paketmanagers nach den manuellen Änderungen, die Sie mit dem vorherigen Befehl vorgenommen haben.$ sudo apt-get updateÜberprüfen Sie die Version des Docker-Pakets, das im offiziellen Repository verfügbar ist.$ apt-cache policy docker-ceInstallieren Sie Docker.$ sudo apt-get install docker-ceSie können die Version von Docker nach der Installation überprüfen.$ docker --versionIn diesem Fall lautet die Ausgabe: Docker Version 18.09.6, Build 481bc77.Starten Sie Docker und sorgen Sie dafür, dass sein Daemon beim Systemstart automatisch geladen wird.$ sudo systemctl start docker$ sudo systemctl enable dockerSobald Sie Docker auf allen Rechnern installiert haben, können Sie direkt mit der Installation von Kubernetes auf Ubuntu fortfahren.

Installation von Kubernetes auf Ubuntu und Cluster-Initialisierung

Jetzt steht der Installation der Kernkomponenten von Kubernetes nichts mehr im Wege.Führen Sie die Befehle als Root auf allen Maschinen aus, die in den Kubernetes-Cluster aufgenommen werden sollen.$ sudo -iFü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 </etc/apt/sources.list.d/kubernetes.listdeb http://apt.kubernetes.io/ kubernetes-xenial mainEOFAlternativ 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.listWo T-Shirt ist ein Tool, das die Standardeingabe liest und die Eingabedaten in die Standardausgabe und definierte Dateien schreibt.Aktualisieren Sie die Paketliste der verfügbaren Repositorys auf Ihrem Ubuntu-System.# apt-get updateInstallieren kubectl, kubeadm und kubectl Es ist wichtig, Kubernetes auf Ubuntu zu installieren.# apt-get install -y kubelet kubeadm kubectlInstallieren Sie keepalived.# apt-get install keepalived# systemctl enable keepalived && systemctl start keepalivedÜberprüfen Sie, ob der Wert 1 für die korrekte Funktionalität von Kubernetes, installiert auf Ubuntu.# sysctl net.bridge.bridge-nf-call-iptablesUm diesen Wert auf 1 Führen Sie den Befehl aus:sysctl net.bridge.bridge-nf-call-iptables=1Bearbeiten Sie die kubeadm-Konfigurationsdatei.# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.confFügen Sie die Zeichenfolge nach der vorhandenen Zeichenfolge „Environment“ ein:Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”Cgroups sind Kontrollgruppen, die die Ressourcennutzung wie Prozessor, Speicher, Festplatte-Ein-/Ausgabe und Netzwerk isolieren.Auf dem Master-Knoten (Docker-Nakivo21Führen Sie 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.21Wo–Pod-Netzwerk-CIDR wird vom Flannel-Treiber benötigt. CIDR (Classless Inter-Domain Routing) definiert die Adresse Ihres Overlay-Netzwerks (z. B. Flannel), das später konfiguriert wird. Die Netzwerkmaske definiert auch, 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 Ausgabe- und Speicherbefehle. Dies ist ein wichtiger Punkt. Das generierte Token wird zum Hinzufügen von Worker-Knoten zum Kubernetes-Cluster benötigt.Führen Sie die folgenden Befehle als Benutzer aus, der kubeadm initIn 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/configWenn Sie diese Befehle nicht ausführen, gibt Kubernetes folgenden Fehler zurück: Die Verbindung zum Server localhost:8080 wurde abgelehnt – haben Sie den richtigen Host oder Port angegeben?Kubernetes kopiert dies nicht. Konfiguration Dateien automatisch in das Benutzerverzeichnis. Sie sollten diesen Vorgang manuell durchführen.Überprüfen Sie die zum Cluster hinzugefügten Knoten# kubectl get nodesSie können einen Master-Knoten sehen, der über die Nicht bereit Status im Kubernetes-Cluster, der auf Ubuntu installiert wird. Dies liegt daran, dass das Overlay-Netzwerk nicht konfiguriert wurde. Konfigurieren Sie Flannel, um das Problem zu beheben. Nicht bereit Status des Kubernetes-Master-Knotens. Erstellen Sie das Verzeichnis zum Speichern von 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 von Containern, die bereitgestellt werden müssen, in der YAML-Konfigurationsdatei definieren, anstatt jeden Befehl manuell in der Linux-Konsole auszuführen. YAML-Dateien werden im Zusammenhang mit Kubernetes auch als Manifestdateien bezeichnet.Erstellen Sie die YAML-Konfigurationsdatei mit folgendem Inhalt:kube-flannel.ymlFühren Sie den Befehl „ “ aus. kubectl apply -f ./kube-flannel.ymlAlternativ finden Sie auf GitHub vorgefertigte kostenlose Beispiele für YAML-Bereitstellungskonfigurationen 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 unter Ubuntu bereitstellen:# kubectl get nodesDer Status des Master-Knotens lautet nun „Bereit“.Stellen Sie sicher, dass Flannel korrekt eingerichtet wurde:# kubectl get pods --all-namespacesSie können sehen, dass der Flannel-Pod ausgeführt wird. Dieser Pod besteht aus zwei Containern – dem Flannel-Daemon und initContainer, der zur Bereitstellung der CNI-Konfiguration an einem für Kubernetes lesbaren Standort verwendet wird.Bei der Installation von Kubernetes unter Ubuntu kann manchmal der folgende Fehler auftreten:Verbindung zum Server nicht möglich: net/http: TLS-Handshake-Zeitüberschreitung.Wie können Sie 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 Standard, Kube-öffentlichund Kube-SystemSie können die Liste der Namespaces abrufen:# kubectl get namespacesWie Sie sich erinnern, ist die grundlegende Bereitstellungseinheit in Kubernetes ein Pod, also eine Sammlung von Containern, die sich Netzwerk und Mount-Namespace teilen. Alle Container des Pods werden auf demselben Kubernetes-Knoten geplant. Überprüfen Sie die verfügbaren Pods:# kubectl -n kube-system get podsWenn Sie den Cluster zurücksetzen/beenden möchten, führen Sie folgenden Befehl aus:# kubeadm resetAuf dem Master-Knoten ist alles in Ordnung. Das bedeutet, dass Sie nun mit der Installation von Kubernetes auf Ubuntu fortfahren und mit dem Hinzufügen von Worker-Knoten zum Cluster fortfahren können.Auf den Worker-Knoten (Docker-Nakivo31, Docker-Nakivo32) Führen Sie den folgenden Befehl aus:# kubeadm join 192.168.101.21:6443 --token d8mbzb.uulxu01jbty8yh4z \ --discovery-token-ca-cert-hash sha256:65ace7a4ff6fff795abf086f18d5f0d97da71d4639a0d0a6b93f42bea4948a79Der Token und der Hash wurden nach der Cluster-Initialisierung mit dem kubeadm init Befehl, wie Sie sich vielleicht erinnern.Überprüfen Sie auf dem Master-Knoten erneut den Cluster-Status.# kubectl get nodesJetzt sehen Sie einen Master- und zwei Worker-Knoten im Kubernetes-Cluster, der auf Ubuntu-Maschinen läuft.Sie können die Kubernetes-Konfiguration überprüfen:# kubectl cluster-info

Bereitstellung eines Pods in Kubernetes

Jetzt können Sie einen Pod mit Containern in Ihrem Kubernetes-Cluster bereitstellen. Wie Sie sich erinnern, sind Container in Kubernetes in Pods enthalten. Wenn Sie YAML-Dateien verwenden, erstellen Sie zur Vereinfachung ein Verzeichnis, in dem Sie diese Dateien speichern können. Wechseln Sie in dieses Verzeichnis und führen Sie die folgenden Befehle aus: kubectl apply -f test.yamlEin solches Verzeichnis wurde bereits bei der Konfiguration von Flannel erstellt – /home/kubernetes-user/kubernetes/Es ist Zeit, einen neuen Pod bereitzustellen. Zunächst müssen Sie eine Bereitstellung erstellen. Die Bereitstellung ist ein Controller-Konzept, das für die Bereitstellung deklarativer Updates für Pods und Replikatsätze verwendet wird. Sie können die Bereitstellung mit einem einzigen Befehl oder mithilfe von YAML-Dateien erstellen.

Beispiel 1 – Bereitstellung von MySQL

Erstellen wir in diesem Beispiel eine YAML-Datei. Der Name der Datei lautet mysql-Bereitstellung.yamlDie Konfiguration sehen Sie in der angehängten Datei.# vim mysql-deployment.yamlEs gibt zwei beliebte Ansätze für das Management von Ressourcen mit kubectlWas ist der Unterschied zwischen kubectl erstellen und kubectl anwenden? Bei Verwendung von kubectl erstellenSie teilen Kubernetes mit, was Sie erstellen, ersetzen oder löschen möchten; dieser Befehl überschreibt alle Änderungen. Alternativ können Sie kubectl anwenden nimmt inkrementelle Änderungen vor, und dieser Befehl kann verwendet werden, um Änderungen zu speichern, die auf ein Live-Objekt angewendet wurden.Erstellen Sie eine Bereitstellung:# kubectl apply -f ./mysql-deployment.yamlKubernetes kann Informationen zu Ihrer Bereitstellung anzeigen.# kubectl describe deployment mysqlPods überprüfen:# kubectl get pooder# kubectl get podsoder# kubectl get pods -l app=mysqlWenn Sie den Status „Ausstehend“ für den Pod sehen, kann dies bedeuten, dass nicht genügend Rechenressourcen vorhanden sind. Versuchen Sie, etwas CPU- und Speicherkapazität hinzuzufügen, um den Status „Ausstehend“ des Pods in Kubernetes zu beheben.Sie können den Dienst bei Bedarf löschen:# kubectl delete service Sie können auch einen Pod löschen:# kubectl delete pod mysql-7b9b7999d8-nz5tm

Beispiel 2 – Bereitstellung von nginx

Lassen Sie uns nginx von einer anderen Methode aus ohne YAML-Dateien bereitstellen.Erstellen Sie eine Bereitstellung.# kubectl create deployment nginx --image=nginxÜberprüfen Sie, ob die Bereitstellung erstellt wurde.# kubectl get deploymentsErstellen Sie einen Dienst.# kubectl create service nodeport nginx --tcp=80:80Ein Dienst kann mithilfe der folgenden Diensttypen erstellt werden: ClusterIP, NodePort, LoadBalance und ExternalName. Wenn der Typ NodePort verwendet wird, wird ein zufälliger Port aus dem Bereich 30000-32767 für den Zugriff auf die bereitgestellten Dienste zugewiesen. Der an diesen Port gesendete Datenverkehr wird an den erforderlichen Dienst weitergeleitet.Überprüfen Sie, ob der Dienst erstellt wurde und auf dem definierten Port empfangsbereit ist.# kubectl get svcMerken 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 gemerkt haben.# curl docker-nakivo31:31453Sie können auch überprüfen, ob der Dienst im Browser eines beliebigen Knotens zugänglich ist. Versuchen Sie, in der Adressleiste des Webbrowsers die folgenden Seiten aufzurufen:http:// 10.101.235.90oderhttp://docker-nakivo31:31453http://docker-nakivo32:31453Wenn alles in Ordnung ist, wird die Begrüßungsseite von nginx angezeigt.Es ist auch möglich, die nginx-Testseite von jedem Rechner aus aufzurufen, der Zugriff auf das Netzwerk hat, mit dem die Kubernetes-Knoten verbunden sind – (192.168.101.0/24) in diesem Fall. Sie können beispielsweise die Webseiten mit Ihrem Browser besuchen:http://192.168.101.21:31453/http://192.168.101.31:31453/http://192.168.101.32:31453/

Einrichten der Webschnittstelle zur Überwachung von Kubernetes

Die Installation von Kubernetes unter Ubuntu ist fast abgeschlossen, aber Sie können für mehr Komfort auch das Kubernetes-Dashboard installieren. Das Kubernetes-Dashboard ist eine Webschnittstelle für das Management und die Überwachung von Kubernetes. Um das Dashboard zu installieren, erstellen Sie die Datei kubernetes-Dashboard.yaml Dateien, ähnlich wie Sie es zuvor vor der Ausführung der Befehle getan haben.# kubectl create -f ./kubernetes-dashboard.yaml# kubectl apply -f ./kubernetes-dashboard.yamlPods überprüfen.# kubectl get pods -o wide --all-namespacesStarten Sie den Proxy zum Kubernetes-API-Server.# kubectl proxyUm die weiteren Befehle in die Konsole einzugeben, öffnen Sie bitte ein weiteres Konsolenfenster. Andernfalls würde der Vorgang abgebrochen werden.Rufen Sie in Ihrem Webbrowser auf dem Master-Knoten die folgende Seite auf:http://localhost:8001Sie können die Testseite sehen.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 von dem 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 –decodeJetzt 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 für das Kubernetes-Dashboard um CPU-, Speicher- und andere Überwachungsparameter zu erweitern. Erstellen Sie eine Manifestdatei mit dem Namen heapster.yaml.# vim heapster.yamlIn der weiteren Aktion stellen Sie Heapster bereit.# kubectl create -f heapster.yamlBearbeiten Sie die Rollenbasierte Zugriffskontrolle (RBAC) 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 Speichermetriken in der Konsole gemessen werden können.# kubectl top nodeJetzt können Sie die Weboberfläche des Kubernetes-Dashboards öffnen und sehen, dass einige Abschnitte, darunter Grafiken zur CPU-Auslastung und Speicherauslastung, hinzugefügt wurden.Ihr Kubernetes-Cluster ist nun konfiguriert und einsatzbereit.

Bereitstellung eines hochverfügbaren Kubernetes-Clusters mit mehreren Mastern unter Ubuntu

Ein Kubernetes-Cluster mit einem Master-Knoten und mehreren Worker-Knoten ist eine gute Option, aber 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 ist es besser, die Bereitstellung eines hochverfügbaren Kubernetes-Clusters mit mehreren Master-Knoten in Betracht zu ziehen. Mit diesem Kubernetes-Cluster-Bereitstellungsmodell 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 bieten kann, 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 der Fehlertoleranz in Abhängigkeit von der Anzahl der Master-Knoten im Kubernetes-Cluster. Wenn Sie beispielsweise einen Cluster mit fünf Master-Knoten haben, kann der Cluster den Ausfall von zwei Master-Knoten überstehen, da drei Master-Knoten weiterhin arbeiten (3 von 5 sind mehr als 50 % und bilden die Mehrheit). Die Größe des Clusters bezieht sich auf die Anzahl der Master-Knoten im Cluster.

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 sind die IP-Adressen, Hostnamen und Rollen der Hosts aufgeführt, die für die Installation des HA-Kubernetes-Clusters auf Ubuntu-Knoten im Testlabor verwendet werden, das in diesem Beispiel erläutert wird.

Einige Befehle sind dieselben wie bei der Installation von Kubernetes auf Ubuntu unter Verwendung des Ein-Master-Knoten-Modells. Aus diesem Grund werden die Kommentare zu einigen Befehlen nicht wiederholt. Sie können auf dieser Seite nach oben scrollen, um die Erläuterungen zu den Befehlen aufzurufen.Bereiten Sie alle Maschinen (HA-Proxy, Master-Knoten und Worker-Knoten) für die Installation von Kubernetes vor, indem Sie Folgendes tun:

• Konfigurieren Sie statische IP-Adressen.
• Hostnamen festlegen. Die Namen aller Hosts müssen in IP-Adressen aufgelöst werden.
• Der SSH-Zugriff muss aktiviert und von Zertifikaten konfiguriert werden.
• Swap muss deaktiviert sein.

Diese Schritte müssen vor Beginn der Docker-Installation auf jedem Rechner durchgeführt werden, ähnlich wie im obigen Abschnitt beschrieben, in dem die Installation von Kubernetes auf Ubuntu von einem Master-Knoten erläutert wurde. Sobald Sie alle Rechner vorbereitet haben, gehen Sie zu (192.168.101.19).

Konfigurieren des HA Proxy Load Balancers

Der HA Proxy Load Balancer wird verwendet, um den eingehenden Datenverkehr zwischen den Kubernetes-Knoten zu verteilen. Der Load Balancer wird vor den Master-Knoten bereitgestellt. Öffnen Sie die Konsole des ha-proxy19 Maschine und führen Sie die unten aufgeführten Aktionen aus.

cfssl installieren

Cfssl (Cloud Flare SSL) ist ein Toolkit, das zur Erstellung verschiedener Zertifikate einschließlich TLS/SSL-Zertifikatsketten verwendet wird.Herunterladen der Binärdateien aus dem offiziellen Repository.# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64Machen 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 versionAktualisieren Sie den Repository-Baum.# apt-get updateInstallieren Sie HA Proxy.# apt-get install haproxyErstellen und bearbeiten Sie die haproxy.cfg Datei.# vim /etc/haproxy/haproxy.cfgFügen Sie diese Zeilen am Ende dieser Konfigurationsdatei hinzu.frontend kubernetesbind 192.168.101.19:6443option tcplogmode tcpdefault_backend kubernetes-master-nodesbackend kubernetes-master-nodesmode tcpbalance roundrobinoption tcp-checkserver docker-nakivo21 192.168.101.21:6443 check fall 3 rise 2server docker-nakivo22 192.168.101.22:6443 check fall 3 rise 2server docker-nakivo23 192.168.101.23:6443 check fall 3 rise 2Starten Sie den Dienst neu.# systemctl restart haproxy

TSL-Zertifikate generieren

Sie können weiterhin die Konsole des HA-Proxy-Rechners verwenden. Erstellen Sie die Konfigurationsdatei für die Zertifizierungsstelle mit dem Namen ca-config.json.# vim ca-config.jsonFügen Sie den folgenden Inhalt zu dieser Konfigurationsdatei hinzu:{ \"signing\": { \"default\": { \"expiry\": \"8760h\" }, \"profiles\": { \"kubernetes\": { \"usages\": [\"signing\", \"key encipherment\", \"server auth\", \"client auth\"], \"expiry\": \"8760h\" } } }}Erstellen Sie die Konfigurationsdatei für die Signaturanforderungsdatei der Zertifizierungsstelle.# vim ca-csr.jsonFügen Sie den Inhalt wie unten gezeigt zu dieser Datei hinzu:{ „CN“: „Kubernetes“, „key“: { „algo“: „rsa“, „Größe“: 2048 }, „names“: [ { „C“: „GB“, „L“: „London“, „O“: „Kubernetes“, „OU“: „CA“, „ST“: „Nakivo“ } ]}Wo:C – Land, zum Beispiel GB (Großbritannien).L – Standort, z. B. Stadt oder Gemeinde.O – organisation.OU – Organisationseinheit (z. B. eine Abteilung, die als Schlüsselinhaber definiert ist).ST – den Bundesstaat oder die Provinz.Generieren Sie nun den öffentlichen und den privaten Schlüssel.# cfssl gencert -initca ca-csr.json | cfssljson -bare caÜberprüfen Sie, ob die ca-key.pem und die ca.pem Schlüssel wurden generiert.# ls -al

Erstellen des Zertifikats für den Etcd-Cluster

Etcd unterstützt die Kommunikation zwischen Servern und Clustern mithilfe der Authentifizierung durch Client-Zertifikate. Sie sollten über ein CA-Zertifikat und ein signiertes Schlüsselpaar für ein Clustermitglied verfügen.Erstellen Sie die Konfigurationsdatei für die Zertifikatssignierungsanforderung.# vim kubernetes-csr.json{ \"CN\": \"kubernetes\", \"key\": { \"algo\": \"rsa\", \"size\": 2048 }, \"names\": [ { \"C\": \"GB\", \"L\": \"London\", \"O\": \"Kubernetes\", \"OU\": \"Kubernetes\", \"ST\": \"Nakivo\" } ]}Nach der Generierung des Zertifikats und des privaten Schlüssels generieren Sie 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 kubernetesListen Sie die Dateien in Ihrem Verzeichnis auf, um zu überprüfen, ob die kubernetes-Schlüssel.pem und die kubernetes.pem Dateien wurden generiert.# ls -alKopieren 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:~Wo ~ ist ein Home-Verzeichnis von Kubernetes-Benutzer auf Ubuntu-Hosts.

Vorbereitung der Ubuntu-Knoten für die Installation von Kubernetes

Führen Sie die in diesem Abschnitt gezeigten Befehle auf allen Master-Knoten 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 der 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-ceDocker ist nun installiert. Cubeadm, kublet und cubectl sind die Kubernetes-Komponenten, die für die Installation von Kubernetes auf Ubuntu erforderlich sind.Installieren Sie die Kubernetes-Komponenten – kubeadm, kublet 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 kubectlNachdem Sie alle Knoten vorbereitet und Docker, Kubelet, Kubeadm und 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 Speicher, der zum Speichern von Schlüsseln sowie 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-Knoten.Installing and configuring etcd on the 192.168.101.21 machine.Erstellen Sie ein Konfigurationsverzeichnis für etcd.# mkdir /etc/etcd /var/lib/etcdWechseln 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/etcdGehen Sie zurück zu Ihrem vorherigen Verzeichnis# 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.gzEntpacken Sie das etcd-Archiv.# tar xvzf etcd-v3.3.9-linux-amd64.tar.gzVerschieben 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.serviceFügen Sie die unten angezeigten Zeichenfolgen zu dieser Datei hinzu.[Unit]Description=etcdDocumentation=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/etcdRestart=on-failureRestartSec=5[Install]WantedBy=multi-user.targetLaden 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-reloadEtcd beim Boot beginnen zu laufen.# systemctl enable etcdEtcd starten.# systemctl start etcdFühren Sie die gleichen Aktionen auf dem zweiten Master-Knoten aus (Docker-Nakivo22 – 192.168.101.21 und Docker-Nakivo23 – 192.168.101.22Der einzige Unterschied bei den für diese Master-Knoten erforderlichen Aktionen besteht darin, dass die etcd.service Konfigurationsdatei. Definieren Sie die korrekten IP-Adressen für jeden anderen Master-Knoten. Beispielsweise die etcd.service Die Konfigurationsdatei muss für den zweiten Master-Knoten wie folgt lauten (192.168.101.22) des aktuellen Kubernetes-Testlabors.[Unit]Description=etcdDocumentation=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/etcdRestart=on-failureRestartSec=5[Install]WantedBy=multi-user.target

Initialisierung der Master-Knoten im Kubernetes-HA-Cluster

Jetzt können Sie die Master-Knoten in Ihrem Kubernetes-HA-Cluster initialisieren, der auf Ubuntu-Maschinen installiert ist.

Initialisierung des Master-Knotens 192.168.101.21

Führen Sie auf dem ersten Master-Knoten die unten beschriebenen Vorgänge aus.Erstellen Sie die YAML-Konfigurationsdatei für kubeadm.# vim config.yamlFügen Sie die Konfigurationsparameter zu dieser Datei hinzu:apiVersion: kubeadm.k8s.io/v1alpha3kind: ClusterConfigurationkubernetesVersion: stableapiServerCertSANs:- 192.168.101.19controlPlaneEndpoint: \"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.pemnetworking: podSubnet: 10.244.0.0/16apiServerExtraArgs: apiserver-count: \"3\"Das als podSubnet (10.244.0.0/16) definierte Netzwerk muss mit dem in der kube-flannel.yml Datei.Initialisieren Sie den Ubuntu-Rechner als Master-Knoten.# kubeadm init --config=config.yamlManchmal wird eine Warnung bezüglich der alten Version einer Konfigurationsdatei angezeigt:Ihre Konfigurationsdatei verwendet eine veraltete API-Spezifikation: „kubeadm.k8s.io/v1alpha3”. Verwenden Sie bitte „kubeadm config migrate –old-config old.yaml –new-config new.yaml”, wodurch die neue, ähnliche Spezifikation unter Verwendung einer neueren API-Version geschrieben wird.Aktualisieren Sie die Version der Konfigurationsdatei mit dem folgenden Befehl:# kubeadm config migrate --old-config config.yaml --new-config config1.yamlEin weiterer Fehler kann auftreten, wenn Sie einen Knoten eines Multi-Master-Kubernetes-Clusters initialisieren, während etcd nicht ausgeführt wird:[ERROR ExternalEtcdVersion]: „https://192.168.101.21:2379/Version“ abrufen: tcp 192.168.101.21:2379 wählen: Verbinden: Verbindung: Verbindung abgelehntÜberprüfen Sie, ob Ihr etcd läuft. Sie können etcd manuell:# systemctl start etcdNach erfolgreicher Initialisierung des Master-Knotens im Kubernetes-Cluster unter Ubuntu erhalten Sie die folgende Meldung in der Anzeige, wie auf dem Screenshot zu sehen ist.Die Ausgabe der erfolgreichen Ausführung dieses Befehls enthält einen Tipp zur Verwendung Ihres Clusters sowie Befehle, die ein Token und einen Zertifikats-Hash enthalten, die für das Hinzufügen von Knoten zum Cluster erforderlich sind. Speichern Sie diese wichtigen Zeichenfolgen, da Sie sie bald benötigen werden. Sie sind auf dem Screenshot gelb markiert und unten dupliziert.Sie können nun eine beliebige Anzahl von Control-Plane-Knoten hinzufügen, indem Sie Zertifizierungsstellen kopieren. und Dienstkontoschlüssel auf jedem Knoten und führen Sie dann als Root Folgendes aus:kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf \ --discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca \ --experimental-control-planeDann können Sie beliebig viele Worker-Knoten hinzufügen, indem Sie auf jedem einzelnen als Root Folgendes ausführen:kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf \ --discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302caFühren Sie die Befehle aus, um den initialisierten Knoten im Cluster zu verwenden.# 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 zum Cluster hinzugefügten Knoten.# kubectl get nodesKopieren 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 apiserver.crt und apiserver.key die sich im Home-Verzeichnis befinden (~) der Kubernetes-Benutzer.$ rm ~/pki/apiserver.*Verschieben Sie die im Home-Verzeichnis gespeicherten Zertifikate in das /etc/kubernetes/ Verzeichnis.$ sudo mv ~/pki /etc/kubernetes/Erstellen Sie die Konfigurations-YAML-Datei für kubeadm.# vim config.yamlDer Inhalt dieser YAML-Datei entspricht dem des ersten Master-Knotens (192.168.101.21Siehe die Konfiguration für die Initialisierung des ersten Master-Knotens oben. Sie können die bereits erstellte Datei kopieren, die auf dem ersten Master-Knoten des Kubernetes-HA-Clusters verwendet wird, der auf Ihren Ubuntu-Maschinen installiert ist.Initialisieren Sie den zweiten Master-Knoten.# kubeadm config migrate --old-config config.yaml --new-config config1.yaml# kubeadm init --config=config1.yamlDie Ausgabe entspricht der Anzeige, die nach der ersten Initialisierung des Master-Knotens im Kubernetes-HA-Cluster angezeigt wurde:Führen Sie ebenfalls die Befehle aus, um den initialisierten Knoten im Cluster zu verwenden.# 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 zum Cluster hinzugefügten Knoten.# kubectl get nodesZwei von drei Master-Knoten wurden zum 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, die Sie für die Initialisierung des zweiten Knotens (192.168.101.22) im Cluster durchgeführt haben.Vergessen Sie nicht, sich die Befehle mit Token und Hashes zum Hinzufügen von Knoten zum Cluster zu notieren, die nach der Initialisierung des Master-Knotens angezeigt werden.Überprüfen Sie, ob alle drei Master-Knoten erfolgreich zum Cluster hinzugefügt wurden.# kubectl get nodes

Installieren von Flannel, um den Status „NotReady“ von Master-Knoten in Kubernetes zu beheben

Installieren wir Flannel. Im Gegensatz zum ersten Beispiel, in dem Sie gelernt haben, wie man Kubernetes auf Ubuntu installiert, um einen einzelnen Master-Cluster zu erstellen, wird Flannel in diesem Beispiel von der YAML-Datei installiert.Führen Sie den Befehl aus, um Flannel zu installieren und das Problem zu beheben. Nicht bereit Status der Knoten, der angezeigt wird, da noch kein Overlay-Netzwerk konfiguriert ist. Erstellen Sie die kube-flannel.yaml Datei mit dem Texteditor vim, zum Beispiel auf dem ersten Master-Knoten.# kubectl apply -f kube-flannel.ymlMerken Sie sich die Adresse des in der config.yaml Datei. Die Netzwerkadresse muss in der kube-flannel.yaml Datei.Überprüfen Sie Ihre Knoten und deren Status.# kubectl get nodesJetzt arbeiten alle Master-Knoten einwandfrei.

Hinzufügen von Worker-Knoten zum Cluster

Nachdem Sie alle Master-Knoten initialisiert haben, können Sie Ihrem Kubernetes-Cluster Worker-Knoten hinzufügen. Fügen wir den ersten Worker-Knoten hinzu (192.168.101.31) zum HA-Kubernetes-Cluster, der auf Ubuntu-Maschinen bereitgestellt ist. Verwenden Sie den Befehl, der nach der Initialisierung der Master-Knoten angezeigt wurde (der Befehl, der Token und Hash enthält), um den Worker-Knoten dem Cluster hinzuzufügen. Führen Sie den Befehl auf dem 192.168.101.31 Maschine.# 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 nodesFügen Sie ebenfalls weitere Worker-Knoten zum Kubernetes-Hochverfügbarkeitscluster hinzu, der auf Ubuntu-Maschinen installiert ist. Sie können jederzeit weitere Worker-Knoten hinzufügen, je nach Ihren Anforderungen. Damit ist das heutige Tutorial fertiggestellt.

Schlussfolgerung

Die Installation von Kubernetes auf Ubuntu ist nicht so schwierig, wie es auf den ersten Blick erscheinen mag. Die Bereitstellung eines Kubernetes-Clusters erfordert zwar einigen Aufwand, bietet aber im Gegenzug viele Vorteile wie ein zentralisiertes, einfaches Management, hohe Skalierbarkeit und Lastenausgleich. Die einfachste Art der Kubernetes-Bereitstellung ist eine Ein-Master-Bereitstellung – Sie sollten Kubernetes auf Ubuntu-Knoten installieren, einschließlich Master- und Worker-Knoten.Wenn Sie eine zuverlässigere Infrastruktur für die Ausführung containerisierter Anwendungen benötigen, sollten Sie die Bereitstellung eines Multi-Master-Kubernetes in Betracht ziehen, das als Kubernetes-Hochverfügbarkeitscluster bekannt ist. Diese Art der Kubernetes-Bereitstellung schließt einen Single Point of Failure aus, und Ihr Cluster kann auch dann weiterlaufen, wenn einige der Master-Knoten ausfallen.Bei beiden Bereitstellungstypen müssen Sie den SSH-Zugriff konfigurieren, statische IP-Adressen und Hostnamen festlegen, Docker installieren, die Verwendung der Swap-Partition deaktivieren und schließlich Kubernetes-Komponenten wie kubeadm, kubectl und kubelet installieren sowie Flannel für Overlay-Netzwerke 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 konfigurieren. Die meisten Schritte zur Konfiguration von Kubernetes, zur Erstellung von Bereitstellungen sowie zum Ausführen von Pods können mit zwei Methoden durchgeführt werden: durch manuelles Ausführen von Befehlen über die Befehlszeilenschnittstelle und durch Verwendung von YAML-Konfigurationsdateien. Mit YAML-Dateien können Sie komplexere Strukturen erstellen und die Verwaltung vereinfachen.Sie können Kubernetes auf Ubuntu installieren und sowohl auf physischen als auch auf virtuellen Maschinen ausführen. Wenn Ihr Kubernetes auf virtuellen Maschinen installiert ist, die in vSphere ausgeführt werden, können Sie zusätzlichen Schutz durch die Verwendung von VMware-Hochverfügbarkeitscluster mit der Fehlertoleranzfunktion. Die in diesem Blogbeitrag behandelten Logiken der Kubernetes-Bereitstellung können auch für die Installation von Kubernetes auf anderen Linux-Distributionen verwendet werden.

Try NAKIVO Backup & Replication

Get a free trial to explore all the solution’s data protection capabilities. 15 days for free. Zero feature or capacity limitations. No credit card required.

Try for Free