So installierst du einen Kubernetes-Cluster mit Kubeadm auf Rocky Linux
Kubernetes oder k8s ist eine Open-Source-Plattform für die Container-Orchestrierung, die die Bereitstellung, Verwaltung und Skalierung von containerisierten Anwendungen automatisiert. Kubernetes ist eine Container-Orchestrierung, die von Google entwickelt wurde und inzwischen als Open-Source-Projekt zum Standard für moderne Anwendungsbereitstellung und Computing-Plattformen geworden ist.
Kubernetes ist die Lösung für die moderne Ära der Containerbereitstellung. Es bietet Service Discovery und Load-Balancing, Storage-Orchestrierung, automatisiertes Rollout und Rollback, selbstheilende Services, Geheimnis- und Konfigurationsmanagement. Kubernetes ermöglicht eine kostengünstige Cloud-native Entwicklung.
In diesem Lernprogramm richtest du den Kubernetes Cluster ein:
- Einrichten der Systeme, d.h. Einrichten der Datei /etc/hosts, Einrichten von SELinux, Aktivieren von Kernelmodulen und Deaktivieren von SWAP.
- Firewalld einrichten, indem wir einige Ports hinzufügen, die für Kubernetes benötigt werden.
- Installation von containerd als Container-Laufzeitumgebung für Kubernetes.
- Installieren von Kubernetes-Paketen wie kubelet, kubeadm und kubectl.
- Installation des Flannel Netzwerk-Plugins für Kubernetes Pods.
- Initialisierung eines Control-Plane Nodes und Hinzufügen von zwei Worker Nodes.
Voraussetzungen
Um dieses Tutorial durchzuführen, brauchst du die folgenden Voraussetzungen:
- Drei oder mehr Rocky Linux Server.
- Einen Nicht-Root-Benutzer mit Root-/Administrator-Rechten.
Einrichten der Systeme
Bevor du mit der Installation der Pakete für die Kubernetes-Bereitstellung beginnst, musst du alle deine Systeme so einrichten, wie es für die Kubernetes-Bereitstellung erforderlich ist. Dazu gehören die folgenden Konfigurationen:
- Richte die richtige /etc/hosts-Datei ein: Jeder Hostname eines Servers muss in die richtige IP-Adresse aufgelöst werden. Dafür gibt es mehrere Möglichkeiten, aber am einfachsten ist es, die Datei /etc/hosts auf allen Servern zu verwenden.
- Firewalld einrichten: Für die Produktionsumgebung ist es immer empfehlenswert, die Firewall sowohl auf der Control-Plane als auch auf den Worker Nodes zu aktivieren.
- SELinux einrichten: Für dieses Beispiel ändern wir die Standardregel von SELinux in „permissive“.
- Aktiviere Kernel-Module: Für Kubernetes müssen einige Kernel-Module auf dem Linux-System aktiviert werden. Die Kernel-Module „overlay“ und „br_netfilter“ werden benötigt, damit iptables den überbrückten Datenverkehr sehen kann.
- DeaktiviereSWAP: Du musst SWAP auf allen Kubernetes-Knoten deaktivieren, sowohl auf der Control-Plane als auch auf den Worker-Knoten. Andernfalls wird der Kubelet-Dienst mit Problemen laufen.
Einrichten der Datei /etc/hosts
In diesem ersten Schritt richtest du den System-Hostnamen und die Datei /etc/hosts auf allen deinen Servern ein. Für diese Demonstration werden wir die folgenden Server verwenden.
Hostname IP Address Used as ------------------------------------------------------- kube-master 192.168.5.10 control-plane kube-kube-worker1 192.168.5.15 worker node kube-kube-worker2 192.168.5.16 worker node
Führe den folgenden hostnamectl-Befehl aus, um den System-Hostnamen auf jedem Server einzurichten.
Für den Control-Plane-Knoten führst du den folgenden Befehl aus, um den System-Hostnamen auf„kube-master“ zu setzen.
sudo hostnamectl set-hostname kube-master
Für die Kubernetes Worker Nodes führst du den folgenden hostnamectl-Befehl aus.
# setup hostname kube-worker1 sudo hostnamectl set-hostname kube-worker1
# setup hostname kube-worker2
sudo hostnamectl set-hostname kube-worker2
Als Nächstes änderst du die Datei /etc/hosts auf allen Servern mit dem folgenden Befehl.
sudo nano /etc/hosts
Füge die folgende Konfiguration in die Datei ein. Achte darauf, dass jeder Hostname auf die richtige IP-Adresse verweist.
192.168.5.10 kube-master 192.168.5.15 kube-worker1 192.168.5.16 kube-worker2
Speichere und schließe die Datei, wenn du fertig bist.
Wenn du abschließend den Ping-Befehl für jeden Hostnamen ausführst, wird dir die richtige IP-Adresse angezeigt, die in der Datei /etc/hosts definiert ist.
ping kube-master -c3 ping kube-worker1 -c3 ping kube-worker2 -c3
Firewalld-Regeln konfigurieren
Kubernetes erfordert, dass einige Ports auf allen deinen Systemen offen sind. Auf dem Standard-RHEL-basierten System ist Firewalld die Standard-Firewall-Anwendung. Für den Einsatz von Kubernetes musst du der Firewalld einige Ports hinzufügen.
Für die Kubernetes Control-Plane musst du die folgenden Ports öffnen:
Protocol Direction Port Range Purpose Used By ----------------------------------------------- TCP Inbound 6443 Kubernetes API server All TCP Inbound 2379-2380 etcd server client API kube-apiserver, etcd TCP Inbound 10250 Kubelet API Self, Control plane TCP Inbound 10259 kube-scheduler Self TCP Inbound 10257 kube-controller-manager Self
Für die Kubernetes Worker Nodes musst du die folgenden Ports öffnen:
Protocol Direction Port Range Purpose Used By -------------------------------------------------- TCP Inbound 10250 Kubelet API Self, Control plane TCP Inbound 30000-32767 NodePort Services† All
Auf dem Control-Plane-Knoten„kube-master“ führst du den folgenden firewall-cmd-Befehl aus, um die Ports der Kubernetes Control-Plane zu öffnen. Lade dann die Firewalld-Regeln neu und überprüfe die Liste der verfügbaren Regeln.
sudo firewall-cmd --add-port=6443/tcp --permanent sudo firewall-cmd --add-port=2379-2380/tcp --permanent sudo firewall-cmd --add-port=10250/tcp --permanent sudo firewall-cmd --add-port=10259/tcp --permanent sudo firewall-cmd --add-port=10257/tcp --permanent
sudo firewall-cmd –reload
sudo firewall-cmd –list-all
Auf den Worker-Knoten„kube-worker1“ und„kube-worker2“ führst du den folgenden Firewall-Befehl aus, um einige Kubernetes-Worker-Ports zu öffnen. Lade dann die Firewalld neu und überprüfe die Liste der verfügbaren Regeln in der Firewalld.
sudo firewall-cmd --add-port=10250/tcp --permanent sudo firewall-cmd --add-port=30000-32767/tcp --permanent
sudo firewall-cmd --reload sudo firewall-cmd --list-all
SELinux und Kernel-Module einrichten und SWAP deaktivieren
Damit der Kubernetes-Dienst kubelet ordnungsgemäß funktioniert, musst du die Standardeinstellung von SELinux auf „permissive“ ändern oder du kannst SELinux komplett deaktivieren. In diesem Beispiel änderst du die SELinux-Richtlinie von„enforcing“ auf„permissive„, was bedeutet, dass du nur von SELinux benachrichtigt wirst.
Führe den folgenden Befehl aus, um die Standard-SELinux-Richtlinie in „permissive“ zu ändern. Überprüfe anschließend den aktuellen Status der SELinux-Richtlinie. Du solltest sehen, dass SELinux immer noch aktiviert ist, aber mit der Richtlinie„permissive„.
sudo setenforce 0 sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
sestatus
Als Nächstes müssen in Kubernetes die Kernelmodule„overlay“ und„br_netfilter“ auf allen Servern aktiviert werden. Dadurch können die iptbales den überbrückten Datenverkehr sehen. Außerdem musst du die Portweiterleitung aktivieren und SWAP deaktivieren.
Führe den folgenden Befehl aus, um die Kernelmodule„overlay“ und„br_netfilter“ zu aktivieren.
sudo modprobe overlay sudo modprobe br_netfilter
Um sie dauerhaft zu aktivieren, erstelle die Konfigurationsdatei„/etc/modules-load.d/k8s.conf„. Dadurch können Linux-Systeme die Kernelmodule während des Systemstarts aktivieren.
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf overlay br_netfilter EOF
Als Nächstes erstellst du die erforderlichen systemctl params mit dem folgenden Befehl.
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf net.bridge.bridge-nf-call-iptables = 1 net.bridge.bridge-nf-call-ip6tables = 1 net.ipv4.ip_forward = 1 EOF
Um die neue sysctl-Konfiguration ohne Neustart anzuwenden, verwende den folgenden Befehl. Du solltest die Liste der standardmäßigen sysctl params auf deinem System erhalten und sicherstellen, dass du die sysctl params, die du gerade hinzugefügt hast, in der Datei„k8s.conf“ erhältst.
sudo sysctl --system
Um SWAP zu deaktivieren, musst du die SWAP-Konfiguration in der Datei„/etc/fstab“ auskommentieren. Das kannst du mit dem einfachen Befehl über sed (Stream-Editor) oder durch manuelles Bearbeiten der Datei /etc/fstab machen.
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
oder
sudo nano /etc/fstab
Schalte das SWAP für die aktuelle Sitzung mit dem folgenden Befehl aus. Überprüfe dann mit dem Befehl„free -m„, ob der SWAP ausgeschaltet ist. Du solltest sehen, dass der SWAP„0“ Werte hat, was bedeutet, dass er jetzt deaktiviert ist.
sudo swapoff -a free -m
Installieren der Container Runtime: Containerd
Um Kubernetes Cluster einzurichten, musst du die Container-Runtime auf allen Servern installieren, damit die Pods laufen können. Für die Kubernetes-Bereitstellung können mehrere Container-Runtimes verwendet werden, z. B. containerd, CRI-O, Mirantis Container Runtime und Docker Engine (über cri-dockerd).
In diesem Beispiel werden wir„containerd“ als Container für unsere Kubernetes-Installation verwenden. Du wirst containerd also auf allen Kubernetes-Knoten installieren. Es gibt mehrere Möglichkeiten, containerd zu installieren. Am einfachsten ist es, vorgefertigte Binärpakete aus dem Docker-Repository zu verwenden.
Bevor du das Repository hinzufügst, führe den folgenden DNF-Befehl aus, um zusätzliche Tools zu installieren: „dnf-utils„.
sudo dnf install dnf-utils
Führe nun den folgenden Befehl aus, um das Docker-Repository für CentOS-basierte Systeme hinzuzufügen.
sudo yum-config-manager \ --add-repo \ https://download.docker.com/linux/centos/docker-ce.repo
Führe den folgenden Befehl aus, um die Repositories auf deinen Rocky-Linux-Systemen zu prüfen und zu verifizieren. Erstelle dann einen neuen Metadaten-Cache. Du wirst sehen, dass das Docker-Repository zu Rocky Linux hinzugefügt wurde.
sudo dnf repolist sudo dnf makecache
Als Nächstes installierst du das containerd-Paket mit dem unten stehenden DNF-Befehl. Gib Y ein, um die Installation zu bestätigen, und drücke ENTER, um die Installation zu starten. Wenn du gefragt wirst, ob du den Docker-GPG-Schlüssel importieren willst, gibst du Y ein, um ihn hinzuzufügen.
sudo dnf install containerd.io
Nachdem die Installation abgeschlossen ist, führe den folgenden Befehl aus, um die Standardkonfiguration von containerd zu sichern und eine neue containerd-Konfigurationsdatei zu erstellen.
sudo mv /etc/containerd/config.toml /etc/containerd/config.toml.orig sudo containerd config default > /etc/containerd/config.toml
Ändere nun die containerd-Konfigurationsdatei„/etc/containerd/config.toml“ mit folgendem Befehl.
sudo nano /etc/containerd/config.toml
Ändere den Wert des cgroup-Treibers„SystemdCgroup = false“ in„SystemdCgroup = true„. Dadurch wird der systemd cgroup-Treiber für die containerd Container-Laufzeit aktiviert.
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc] ... [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options] SystemdCgroup = true
Wenn du fertig bist, speichere und schließe die Datei.
Als nächstes führst du den folgenden systemctl-Befehl aus, um den containerd-Dienst zu starten und zu aktivieren. Dadurch wird der containerd-Dienst beim Systemstart automatisch ausgeführt.
sudo systemctl enable --now containerd
Überprüfe schließlich den containerd-Dienst mit dem folgenden Befehl. Du solltest sehen, dass der containerd-Dienst aktiviert ist und beim Systemstart automatisch ausgeführt wird. Und der aktuelle Status des containerd-Dienstes ist running.
sudo systemctl is-enabled containerd sudo systemctl status containerd
Installation der Kubernetes-Pakete
Du hast die Container-Laufzeitumgebung containerd installiert. Jetzt installierst du die Kubernetes-Pakete auf allen deinen Rocky Linux-Systemen. Dazu gehören kubeadm für das Bootstrapping des Kubernetes-Clusters, kubelet, die Hauptkomponente des Kubernetes-Clusters, und kubectl, das Kommandozeilenprogramm zur Verwaltung des Kubernetes-Clusters.
In diesem Beispiel werden wir Kubernetes-Pakete über das von Kubernetes bereitgestellte Repository installieren. Du fügst also das Kubernetes-Repository zu allen deinen Rocky-Linux-Systemen hinzu.
Führe den folgenden Befehl aus, um das Kubernetes-Repository für RHEL/CentOS-basierte Betriebssysteme hinzuzufügen.
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo [kubernetes] name=Kubernetes baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch enabled=1 gpgcheck=1 gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg exclude=kubelet kubeadm kubectl EOF
Überprüfe nun die Liste der Repositories und erstelle mit dem unten stehenden dnf-Befehl einen neuen Metadaten-Cache. Du solltest sehen, dass das Kubernetes-Repository für Rocky Linux-Systeme hinzugefügt wurde.
sudo dnf repolist sudo dnf makecache
Als nächstes installierst du die Kubernetes-Pakete mit dem folgenden dnf-Befehl. Gib Y ein, um die Installation zu bestätigen und drücke ENTER, um fortzufahren, damit die Installation beginnt.
sudo dnf install kubelet kubeadm kubectl --disableexcludes=kubernetes
Nachdem die Installation abgeschlossen ist, führe den folgenden systemctl-Befehl aus, um den kubelet-Dienst zu starten und zu aktivieren. Überprüfe dann den Kubelet-Dienst und stelle sicher, dass er auf allen Knoten aktiviert ist und läuft.
Dieser Dienst ist der wichtigste Kubernetes-Dienst, der auf alle Ereignisse wartet, wenn du den Cluster initialisierst oder den Knoten in den Cluster einbindest.
sudo systemctl enable --now kubelet
Installation des CNI-Plugins: Flannel
Kubernetes unterstützt verschiedene Container Network Plugins wie AWS VPC für Kubernetes, Azure CNI, Cilium, Calico, Flannel und viele mehr. In diesem Beispiel werden wir Flannel als CNI-Plugin für die Kubernetes-Bereitstellung verwenden. Dazu musst du die Binärdatei von Flannel auf allen Kubernetes-Knoten installieren.
Führe den folgenden Befehl aus, um ein neues Verzeichnis„/opt/bin“ zu erstellen. Lade dann die Binärdatei von Flannel in dieses Verzeichnis herunter.
mkdir -p /opt/bin/ sudo curl -fsSLo /opt/bin/flanneld https://github.com/flannel-io/flannel/releases/download/v0.19.0/flanneld-amd64
Mache nun die Binärdatei„flanneld“ ausführbar, indem du die Berechtigung der Datei mit dem folgenden Befehl änderst. Diese„flanneld„-Binärdatei wird automatisch ausgeführt, wenn du das Pod-Netzwerk-Addon einrichtest.
sudo chmod +x /opt/bin/flanneld
Kubernetes Control Plane initialisieren
Du hast alle Abhängigkeiten und Anforderungen für den Einsatz von Kubernetes Cluster erfüllt. Jetzt startest du den Kubernetes Cluster, indem du den Control Plane-Knoten zum ersten Mal initialisierst. In diesem Beispiel wird die Kubernetes Control Plane auf dem Server„kubem-master“ mit der IP-Adresse„192.168.5.10“ installiert.
Bevor du den Control Plane-Knoten initialisierst, führe den folgenden Befehl aus, um zu prüfen, ob die Kernel-Module„br_netfilter“ aktiviert sind. Wenn du eine Ausgabe des Befehls erhältst, bedeutet das, dass das Modul„br_netfilter“ aktiviert ist.
lsmod | grep br_netfilter
Als Nächstes führst du den folgenden Befehl aus, um die für den Kubernetes Cluster benötigten Images herunterzuladen. Dieser Befehl lädt alle Container-Images herunter, die für die Erstellung des Kubernetes-Clusters benötigt werden, z. B. coredns, kube-api server, etcd, kube-controller, kube-proxy und das pause container image.
sudo kubeadm config images pull
Nachdem der Download abgeschlossen ist, führe den folgenden„kubeadm init„-Befehl aus, um den Kubernetes-Cluster auf dem„kube-master„-Server zu initialisieren. Dieser Knoten„kube-master“ wird automatisch als Kubernetes Control Plane ausgewählt, da dies die erste Initialisierung des Clusters ist.
- Außerdem geben wir in diesem Beispiel als Netzwerk für Pods„10.244.0.0/16“ an, das ist der Standard-Netzwerkbereich für das Flannel CNI Plugin.
- Mit„–apiserver-advertise-address“ wird festgelegt, unter welcher IP-Adresse der Kubernetes-API-Server läuft; in diesem Beispiel wird die interne IP-Adresse„192.168.5.10“ verwendet.
- Für die Option„–cri-socket“ geben wir hier den CRI-Socket für den Container Runtime-Socket an, der unter„/run/containerd/containerd.sock“ verfügbar ist. Wenn du eine andere Container Runtime verwendest, musst du den Pfad der Socket-Datei ändern oder du kannst die Option „–cri-socket“ einfach entfernen, da kubeadm den Container Runtime-Socket automatisch erkennt.
sudo kubeadm init --pod-network-cidr=10.244.0.0/16 \ --apiserver-advertise-address=192.168.5.10 \ --cri-socket=unix:///run/containerd/containerd.sock
Wenn die Initialisierung abgeschlossen ist, siehst du die Meldung„Your Kubernetes control-plane has initialized successfully!“ mit einigen wichtigen Ausgabemeldungen für die Einrichtung der Kubernetes-Anmeldeinformationen und die Bereitstellung des Pod-Netzwerk-Add-ons, wie du den Worker-Node zu deinem Kubernetes-Cluster hinzufügst.
Bevor du den Kubernetes Cluster nutzen kannst, musst du die Kubernetes-Anmeldeinformationen einrichten. Führe den folgenden Befehl aus, um die Kubernetes-Anmeldedaten einzurichten.
mkdir -p $HOME/.kube sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config sudo chown $(id -u):$(id -g) $HOME/.kube/config
Jetzt kannst du den Befehl„kubectl“ verwenden, um mit deinem Kubernetes-Cluster zu interagieren. Führe den folgenden„kubectl„-Befehl aus, um die Kubernetes-Cluster-Informationen zu überprüfen. Du solltest sehen, dass die Kubernetes Control Plane und das Coredns laufen.
kubectl cluster-info
Um vollständige Informationen über deine Kubernetes zu erhalten, kannst du die Option dump verwenden – also „kubectl cluster-info dump„.
Nachdem die Kubernetes Control Plane läuft, führst du den folgenden Befehl aus, um das Flannel Pod Netzwerk-Plugin zu installieren. Dieser Befehl führt automatisch die Binärdatei„flanneld“ aus und startet einige Flannel Pods.
kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml
Wenn deine Kubernetes-Installation erfolgreich war, solltest du sehen, dass alle Haupt-Pods für Kubernetes, einschließlich der Flannel-Pods, laufen.
kubectl get pods --all-namespaces
Hinzufügen von Worker Nodes zu Kubernetes
Nachdem du die Kubernetes Control Plane auf dem „kube-master“ Server initialisiert hast, fügst du die Worker Nodes„kube-worker1“ und„kube-worker2“ zum Kubernetes Cluster hinzu.
Gehe zum„kube-worker1„-Server und führe den folgenden „kubeadm join“-Befehl aus, um den„kube-worker1“ zum Kubernetes Cluster hinzuzufügen. Du kannst unterschiedliche Token und ca-cert-hash haben. Du kannst die Details dieser Informationen in der Ausgabemeldung sehen, wenn du den Control Plane Node initialisierst.
kubeadm join 192.168.5.10:6443 --token wlg23u.r5x2nxw2vdu95dvp \ --discovery-token-ca-cert-hash sha256:71fd28ac2b8108a3d493648a9c702acd2e39a8a0e7efc07326d7b0384c929066
In der folgenden Ausgabe kannst du sehen, dass der Server„kube-worker1“ dem Kubernetes Cluster beigetreten ist.
Als Nächstes gehst du zum Server„kube-worker2“ und führst den Befehl„kubeadm join“ aus, um„kube-worker2“ zum Kubernetes Cluster hinzuzufügen.
kubeadm join 192.168.5.10:6443 --token wlg23u.r5x2nxw2vdu95dvp \ --discovery-token-ca-cert-hash sha256:71fd28ac2b8108a3d493648a9c702acd2e39a8a0e7efc07326d7b0384c929066
Wenn der Vorgang abgeschlossen ist, siehst du die gleiche Meldung.
Gehe nun zurück zum Control Plane Server„kube-master“ und führe den folgenden Befehl aus, um alle laufenden Pods im Kubernetes Cluster zu überprüfen. Du solltest sehen, dass es auf jeder Kubernetes-Komponente zusätzliche Pods gibt.
kubectl get pods --all-namespaces
Überprüfe schließlich alle verfügbaren Knoten im Kubernetes-Cluster mit dem folgenden Befehl „kubectl“. Du solltest sehen, dass der Server„kube-master“ als Kubernetes Control Plane läuft und die Server„kube-worker1“ und„kube-worker2“ als Worker Nodes.
kubectl get nodes -o wide
Fazit
In diesem Lernprogramm hast du die Einrichtung des Kubernetes-Clusters mit drei Rocky-Linux-Servern abgeschlossen. Der Kubernetes Cluster läuft mit einer Control Plane und zwei Worker Nodes. Er läuft mit containerd als Container-Laufzeitumgebung für deinen Kubernetes Cluster und dem Flannel-Netzwerk-Plugin für die Vernetzung der Pods in deinem Cluster. Wenn du den Kubernetes Cluster vollständig konfiguriert hast, kannst du mit dem Deployment deiner Anwendungen in den Kubernetes Cluster beginnen oder versuchen, das Kubernetes Dashboard zu installieren, um mehr über deine Kubernetes-Umgebung zu erfahren.