Kubernetes Cluster mit Kubeadm auf Ubuntu 22.04 einrichten

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:

1. Einrichten der Systeme, d.h. Einrichten der Datei /etc/hosts, Aktivieren der Kernel-Module und Deaktivieren von SWAP.
2. Einrichten der UFW-Firewall durch Hinzufügen einiger Ports, die für Kubernetes erforderlich sind.
3. Installation von containerd als Container-Laufzeitumgebung für Kubernetes.
4. Installieren von Kubernetes-Paketen wie kubelet, kubeadm und kubectl.
5. Installation des Flannel Netzwerk-Plugins für Kubernetes Pods.
6. 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 Ubuntu 22.04 Server.
• Einen Nicht-Root-Benutzer mit Root-/Administrator-Rechten.

Einrichten der Systeme

Bevor du mit der Installation der Pakete für den Kubernetes-Einsatz beginnst, musst du alle deine Systeme so einrichten, wie es für den Kubernetes-Einsatz 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 die einfachste ist die Verwendung der Datei /etc/hosts auf allen Servern.
• UFW-Firewall einrichten: Für die Produktionsumgebung ist es immer empfehlenswert, die Firewall sowohl auf der Control-Plane als auch auf den Worker Nodes zu aktivieren.
• 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.
• SWAP deaktivieren: 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
--------------------------------------------
cplane1     192.168.5.10      control-plane
worker1     192.168.5.25      worker node
worker2     192.168.5.26      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„cplane1“ einzurichten.

sudo hostnamectl set-hostname cplane1

Für die Kubernetes Worker Nodes führst du den folgenden hostnamectl-Befehl aus.

# setup hostname worker1
sudo hostnamectl set-hostname worker1

# setup hostname worker2
sudo hostnamectl set-hostname 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 cplane1
192.168.5.25 worker1
192.168.5.26 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 cplane1 -c3
ping worker1 -c3
ping worker2 -c3

UFW-Firewall konfigurieren

Kubernetes verlangt, dass einige Ports auf allen deinen Systemen offen sind. Auf dem Standard-Ubuntu-System wird die UFW-Firewall als Standard-Firewall verwendet. Für den Einsatz von Kubernetes musst du der UFW-Firewall 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

Bevor du UFW-Regeln hinzufügst, musst du die OpenSSH-Anwendung mit dem unten stehenden Befehl zu deiner Firewall hinzufügen. Aktiviere dann die UFW-Firewall. Wenn du zur Bestätigung aufgefordert wirst, gib„y“ ein, um die UFW-Firewall zu aktivieren und auszuführen.

sudo ufw allow "OpenSSH"
sudo ufw enable

Auf dem Control-Plane-Knoten„cplane1“ führst du den folgenden ufw-Befehl aus, um die Ports zu öffnen.

sudo ufw allow 6443/tcp
sudo ufw allow 2379:2380/tcp
sudo ufw allow 10250/tcp
sudo ufw allow 10259/tcp
sudo ufw allow 10257/tcp

sudo ufw status

Auf den Worker-Knoten„worker1“ und„worker2“ führst du den folgenden ufw-Befehl aus, um einige Ports zu öffnen.

sudo ufw allow 10250/tcp
sudo ufw allow 30000:32767/tcp

sudo ufw status

Aktiviere Kernel-Module und deaktiviere SWAP

In Kubernetes müssen die Kernel-Module„overlay“ und„br_netfilter“ auf allen Servern aktiviert sein. 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 Befehl sed (Stream-Editor) machen oder die Datei /etc/fstab manuell bearbeiten.

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 einen Kubernetes Cluster einzurichten, musst du die Container-Laufzeitumgebung 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 dieser Demonstration werden wir „containerd“ als Container für unser Kubernetes-Deployment verwenden. Du wirst containerd also auf allen Servern, der Control-Plane und den Worker Nodes installieren.

Es gibt mehrere Möglichkeiten, containerd zu installieren. Am einfachsten ist es, vorgefertigte Binärpakete aus dem Docker-Repository zu verwenden.

Führe nun den folgenden Befehl aus, um das Docker-Repository und den GPG-Schlüssel hinzuzufügen.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisiere den Paketindex auf deinem Ubuntu-System mit dem unten stehenden Befehl.

sudo apt update

Installiere nun das containerd-Paket mit dem unten stehenden apt-Befehl. Die Installation wird nun beginnen.

sudo apt install containerd.io

Nachdem die Installation abgeschlossen ist, führe den folgenden Befehl aus, um den containerd-Dienst zu beenden.

sudo systemctl stop containerd

Sichere die Standardkonfiguration von containerd und erstelle eine neue mit dem folgenden Befehl.

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.

sudo systemctl start containerd

Zuletzt überprüfst du den containerd-Dienst mit dem folgenden Befehl. Du solltest sehen, dass der containerd 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 des Kubernetes-Pakets

Du hast die Container-Laufzeitumgebung containerd installiert. Jetzt installierst du die Kubernetes-Pakete auf allen deinen Ubuntu-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. Also fügst du das Kubernetes-Repository zu allen deinen Ubuntu-Systemen hinzu.

Führe den folgenden apt-Befehl aus, um einige Paketabhängigkeiten zu installieren.

sudo apt install apt-transport-https ca-certificates curl -y

Füge nun das Kubernetes-Repository und den GPG-Schlüssel mit folgendem Befehl hinzu.

sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Aktualisiere dein Ubuntu-Repository und den Paketindex.

sudo apt update

Wenn die Aktualisierung abgeschlossen ist, installiere die Kubernetes-Pakete mit dem folgenden apt-Befehl. Gib Y ein, um die Installation zu bestätigen und drücke ENTER, um fortzufahren und die Installation beginnt.

sudo apt install kubelet kubeadm kubectl

Nachdem die Installation abgeschlossen ist, führe den folgenden Befehl aus, um die aktuelle Version der Kubernetes-Pakete zu pinnen. Dadurch wird verhindert, dass die Kubernetes-Pakete automatisch aktualisiert werden und die Versionsverschiebung zwischen den Kubernetes-Paketen verhindert.

sudo apt-mark hold kubelet kubeadm kubectl

CNI (Container Network Interface) Plugin installieren: 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 die Binärdatei „flanneld“ ausführbar, indem du die Berechtigung der Datei mit dem unten stehenden 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„cplane1“ mit der IP-Adresse„192.168.5.10“ installiert.

Bevor du den Control Plane-Knoten initialisierst, führe den folgenden Befehl aus, um zu überprü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 Befehl„kubeadm init“ aus, um den Kubernetes Cluster auf dem Server„cplane1“ zu initialisieren. Dieser Knoten„cplane1“ 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 Socket der Container Runtime automatisch erkennen wird.

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

Unten siehst du die Ausgabe, wenn du den Kubernetes Cluster auf dem Server„cplane1“ initialisierst.

Wenn die Initialisierung abgeschlossen ist, siehst du eine Meldung wie„Deine Kubernetes Control-Plane wurde erfolgreich initialisiert!“ mit einigen wichtigen Ausgabemeldungen zum Einrichten der Kubernetes-Anmeldeinformationen und zum Deployment 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

Überprüfe die Liste der laufenden Pods in deiner Kubernetes mit dem folgenden Befehl. Wenn deine Kubernetes-Installation erfolgreich ist, solltest du sehen, dass alle Haupt-Pods für Kubernetes laufen.

kubectl get pods --all-namespaces

Hinzufügen von Worker Nodes zu Kubernetes

Nachdem du die Kubernetes Control Plane auf dem Server„cplane1“ initialisiert hast, fügst du die Worker Nodes„worker1“ und„worker2“ zum Kubernetes Cluster hinzu.

Gehe zum Server„worker1“ und führe den folgenden Befehl„kubeadm join“ aus, um „worker1“ zum Kubernetes Cluster hinzuzufügen. Möglicherweise hast du unterschiedliche Token und ca-cert-hash. 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 po3sb1.oux4z76nwb0veuna \
--discovery-token-ca-cert-hash sha256:f5068150fabaf85f3d04e19a395c60d19298ba441e2d9391e20df3267ea6cd28

In der folgenden Ausgabe kannst du sehen, dass der Server„worker1“ dem Kubernetes Cluster beigetreten ist.

Als Nächstes gehst du zum Server„worker2“ und führst den Befehl„kubeadm join“ aus, um den„worker2“ dem Kubernetes Cluster hinzuzufügen.

kubeadm join 192.168.5.10:6443 --token po3sb1.oux4z76nwb0veuna \
--discovery-token-ca-cert-hash sha256:f5068150fabaf85f3d04e19a395c60d19298ba441e2d9391e20df3267ea6cd28

Wenn der Vorgang abgeschlossen ist, siehst du die gleiche Meldung.

Gehe nun zurück zum Control Plane Server „cplane1“ 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„cplane1“ als Kubernetes Control Plane und die Server„worker1“ und„worker2“ als Worker Nodes laufen.

kubectl get nodes -o wide

Fazit

In diesem Tutorial hast du die Einrichtung des Kubernetes-Clusters mit drei Ubuntu 22.04-Servern mit Knoten 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.