Supercomputer: Wir bauen ein Raspberry Pi Kubernetes Cluster

Der Raspberry Pi ist nicht unbedingt für hochverfügbare Anwendungen gemacht worden. Allerdings hat er inzwischen mehr Rechenpower und kann sogar als Desktop-Ersatz verwendet werden. Um auch größere Anwendungen (bspw. Minecraft) kaufen lassen zu können, bauen wir uns ein Raspberry Pi Kubernetes Cluster. Dafür kannst du so viele Raspberry Pi’s nutzen, wie du möchtest – umso mehr, umso besser! Aber auch mit nur einem einzigen Pi können wir die Power von Kubernetes nutzen!

Zubehör

Folgendes Zubehör brauchst du, für dein Kubernetes Cluster aus Raspberry Pi’s:

• Mehrere Raspberry Pi’s (empfohlen sind mind. 4 GB RAM). Außerdem pro Pi noch folgendes:
  • Micro SD Karte (je nach Anwendungen mit entsprechend viel Speicher – ich empfehle mindestens 128 GB)
  • USB C Stromversorgung
  • optional: Ethernetkabel (um Verbindungsprobleme über Wi-Fi zu vermeiden)
• optional: Stapelbare Cluster Gehäuse

Theoretisch kannst du einen einzelnen Raspberry Pi nutzen. Interessanter wird es allerdings, sobald wir mehrere Worker-Nodes (Raspberry Pi’s) haben, da wir so auf und ab skalieren können. Ich empfehle daher mindestens zwei Pi’s.

Darüber hinaus stellt dieses Tutorial keine komplette Alternative zu einem Kubernetes Buch bzw. Online-Kurs dar. Auch die offizielle Dokumentation ist hervorragend, wenn auch etwas trocken zu lesen.

 

Vorbereitung und Installation von Kubernetes auf dem Raspberry Pi

Wir nutzen eine „Light-Kubernetes“ Version von Rancher, die ressourcenschonender ist. Statt dem Spitznamen K8s (Kubernetes  hat 8 Zeichen zwischen K und S) heißt diese Version K3s.

Initiales Raspberry Pi Setup

Die folgenden Schritte müssen auf allen Raspberry Pi’s ausgeführt werden. Du kannst die Schritte nacheinander auf allen Pi’s ausführen. Wir fangen mit dem Setup an. Hierfür nutzen wir das Raspberry Pi OS Lite, welches ohne Desktop kommt. Wir sparen dadurch Ressourcen, da wir den Desktop nicht nutzen werden. Die Installation und Aktivierung von SSH, sowie ggf. die Einstellung des Wi-Fi Passworts können wir komplett headless durchführen.

Anschließend loggen wir uns nacheinander in jeden Raspberry Pi per SSH ein (User: pi, Passwort: raspberry) und ändern zu aller erst das Standardpasswort (optional):

passwd

Anschließend aktualisieren wir die Paketquellen, was ein wenig dauern kann:

sudo apt-get update && sudo apt-get upgrade --yes

Hostnamen ändern

Nun vergeben wir jedem Raspberry Pi einen eindeutigen Hostnamen, denn bisher heißen alle nur raspberrypi. Dazu rufen wir folgendes auf:

sudo nano /etc/hostname

Der erste Pi bekommt den Namen kube-master und jeder weitere Pi wird kube-worker-n benannt, wobei n für die Nummer steht (1, 2, 3, …). Speichere mit STRG+O, beende den Editor mit STRG+X.

Nun müssen wir noch die hosts-Datei anpassen.

sudo nano /etc/hosts

Passe die Datei so an, dass am Ende die IP 127.0.0.1 auf den gewählten Hostnamen zeigt:

127.0.0.1       localhost
::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

127.0.0.1       kube-master

Nun fehlen noch ein paar Schritte:

Container Funktionen aktivieren

sudo nano /boot/cmdline.txt

Füge ans Ende der Datei folgendes ein (mit Leerzeichen):

 cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory

Debian Firewall Konfiguration ändern (zu Legacy):

sudo update-alternatives --set iptables /usr/sbin/iptables-legacy
sudo update-alternatives --set ip6tables /usr/sbin/ip6tables-legacy
sudo reboot

Am Ende wird neu gestartet.

K3s auf Master installieren

Diesen Schritt führen wir nur auf dem ersten Raspberry Pi (kube-master) aus:

export K3S_KUBECONFIG_MODE="644"
curl -sfL https://get.k3s.io | sh -

Die Ausgabe am Ende sollte folgendermaßen aussehen:

Created symlink /etc/systemd/system/multi-user.target.wants/k3s.service → /etc/systemd/system/k3s.service.
[INFO] systemd: Starting k3s

Wir können den Status einfach mittels sudo systemctl status k3s prüfen.

Als Nächstes brauchen wir noch den erstellten Token. Dazu rufen wir Folgendes auf:

sudo cat /var/lib/rancher/k3s/server/node-token

Kopiere den Inhalt, da wir ihn gleich in den Worker-Nodes angeben müssen.

 

Installation von K3s auf den Worker-Nodes

(Dieser Schritt entfällt, falls du nur einen Raspberry Pi nutzt)

In den folgenden Befehlen musst du den Token anpassen:

export K3S_KUBECONFIG_MODE="644"
export K3S_URL="https://kube-master:6443"
export K3S_TOKEN="K10f6b6c1f1c860e3c1d6992d33a11138d358b39e6c7f307ed82c25f31d1d72f76d::server:984a34ab2f1037afa2718d8a3cbb570a"
curl -sfL https://get.k3s.io | sh -

Die Installation und den Status können wir anschließend hiermit prüfen:

sudo systemctl status k3s-agent

 

Nachdem alle Worker registriert sind, können wir auf kube-master nachsehen, ob auch alle wirklich verfügbar sind:

sudo k3s kubectl get node

Je nachdem wie viele Raspberry Pi’s in Benutzung sind, sieht die Ausgabe so oder so ähnlich aus:

NAME            STATUS   ROLES                  AGE   VERSION
kube-master     Ready    control-plane,master   19m   v1.22.5+k3s1
kube-worker-1   Ready                     15m   v1.22.5+k3s1

 

Optional: Kubernetes Cluster Client GUI

Im Prinzip können wir unser Raspberry Pi Kubernetes Cluster komplett vom Terminal aus steuern. Auf der Dokumentationsseite stehen alle wichtigen Befehle. Allerdings ist es für die Meisten jedoch komfortabler, ein User Interface zu verwenden. Hier gibt es verschiedenste GUIs. Mir persönlich gefällt LENS sehr gut, welches für alle gängigen Betriebssysteme vorhanden ist. Auch dieser Schritt ist optional.

Lade LENS herunter und installiere es auf deinem Computer. Anschließend wählst du File -> Add Cluster -> Paste as Text. Den Inhalt dafür bekommst du wieder über den kube-master.

Auf dem Pi rufen wir Folgendes auf und kopieren den Text in Lens:

cat /etc/rancher/k3s/k3s.yaml

Du musst lediglich 127.0.0.1 bzw. localhost mit der IP-Adresse bzw. dem Hostnamen (kube-master) ersetzen. Anschließend siehst du alle Informationen zu deinem Raspberry Pi Kubernetes Cluster!

BILD

 

Anwendungen über K8s deployen

So weit, so gut. Wir werden unsere erste Anwendung auf unserem Cluster deployen, d.h. wir werden mehrere Instanzen einer Anwendung im Cluster laufen lassen. Auf einem Worker-Node können mehrere Instanzen der gleichen oder von unterschiedlichen Anwendungen parallel laufen. Ein Load-Balancer wählt automatisch eine Instanz aus, die dann unsere Anfrage bearbeitet.

Als erste Anwendung erstellen wir ein Webserver Cluster über Kubernetes. Dafür nutzen wir nginx und deployen mehrere Pods (Instanzen) in unserem Cluster. Dadurch können die verschiedenen Instanzen parallel arbeiten und eine neue Anfrage kann direkt prozessiert werden.

Alle K8s Konfigurationen (Deployment Sets, Service Definitionen, etc.) werden über YAML Dateien erstellt, daher fangen wir damit an. Du kannst die Schritte ebenfalls über LENS oder ein anderes UI ausführen, jedoch zeige ich hier den Weg über die Kommandozeile.

Du findest alle YAML Dateien auch im Repository und kannst dieses auch einfach klonen und lediglich kubectl apply -f filename.yaml für alle Dateien ausführen. Das spart Copy-and-paste Arbeit.

 

Wir erstellen ein Deployment Set (unsere Anwendung) mit folgendem Inhalt:

sudo nano nginx-deployment.yaml

Damit das Deployment-Set aktiv wird, müssen wir es ausführen:

kubectl apply -f nginx-deployment.yaml

Das war es schon! Nun werden die eingestellten 4 Instanzen erzeugt. Falls du das Deployment-Set ändern willst (bspw. mehr oder weniger Instanzen einstellen), kannst du die Datei bearbeiten und einfach erneut kubectl apply ausführen. Zum Verständnis: Wir haben hier ein nginx Image von Dockerhub geladen. Du kannst auch ein eigenes Image mit deiner Anwendung erstellen und dieses verwenden.

 

Anschließend prüfen wir noch den Status. Nach einem Moment sollte es so aussehen:

pi@kube-master:~ $ kubectl get pods -o wide
NAME                                READY   STATUS    RESTARTS   AGE     IP           NODE          NOMINATED NODE   READINESS GATES
nginx-deployment-7fc67cd68d-xgdng   1/1     Running   0          119s    10.42.0.25   kube-master              
nginx-deployment-7fc67cd68d-5lc66   1/1     Running   0          119s    10.42.0.24   kube-master              
nginx-deployment-7fc67cd68d-v8srl   1/1     Running   0          119s    10.42.0.26   kube-worker-1              
nginx-deployment-7fc67cd68d-f2x48   1/1     Running   0          119s    10.42.0.27   kube-worker-1              

All unsere 4 Container (Pods) laufen jetzt auf verschiedenen Nodes! Ich habe zwei Raspberry Pi’s angeschlossen und auf jedem laufen zwei Instanzen.

Die nächste wichtige Frage ist, wie können wir einen Pod aufrufen? Wir sehen zwar IP-Adressen angezeigt, allerdings gelten diese nur innerhalb des Kubernetes Cluster. Die Antwort darauf ist, dass wir einen K8s Service auf jedem Raspberry Pi brauchen, der quasi Port-Forwarding betreibt (d.h. einen Port öffnet).

K8s Services

Wir erstellen also eine weitere Datei (nginx-nodeport.yaml) und fügen folgenden Inhalt ein:

Anschließend wieder ausführen:

kubectl apply -f nginx-nodeport.yaml

Schauen wir uns nun den Service an:

pi@kube-master:~ $ kubectl get services
NAME             TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
nginx-nodeport   NodePort    10.43.134.93           80:30001/TCP   93s

Wir haben unser Port-Forwarding eingerichtet. Prüfen kannst du das ganz einfach, indem du z.B. über curl die Cluster-IP eines beliebigen Containers aufrufst (in meinem Fall z.B.: curl -k 10.42.0.25).

Kubernetes Ingress

Der nächste Schritt ist, dass wir auch von außerhalb des Raspberry Pi Clusters die Anwendung aufrufen können. Dazu brauchen wir einen Ingress. Dieser ist quasi das Gateway zur Außenwelt, worüber der Traffic geleitet wird:

Auf der Dokumentationsseite wird gesagt, dass wir einen Ingress-Controller brauchen, daher installieren wir diesen zunächst:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.1/deploy/static/provider/cloud/deploy.yaml

Anschließend erstellen wir unsere nginx-ingress.yaml Datei.

Hier habe ich eine imaginäre Domain (my-kubernetes-example.com) genommen. Du kannst natürlich eine bestehende Domain nutzen, oder einfach auf einem anderen System die Hostfile anpassen. Als IP-Adresse nimmst du die Netzwerk-IP des Raspberry Pi Kube-Master (bei mir: 192.168.1.5).

Wir führen auch diese Datei wieder aus:

kubectl apply -f nginx-ingress.yaml

Anschließend kannst du auf deinem PC die eingestellte Domain aufrufen, woraufhin wir die nginx Default-Seite sehen:

Nun kannst du z.B. eine WordPress Website auf deinem Cluster laufen lassen.

 

Weiteres zu K3s

Falls du mehr zu der Kubernetes Version von Rancher (k3s) erfahren möchtest, kannst du einen Blick in die Dokumentation werfen. Hier steht u.a. auch, wie man das ganze wieder deinstallieren kann. Das ist z.B. nützlich, falls bei der Installation einen Pi fälschlicherweise als Master/Worker gesetzt hat.

 

Helm – Der Kubernetes Package Manager

Das deployen von solchen Anwendungen auf Kubernetes wirkt auf den ersten Blick etwas schwierig – vor allem, wenn wir bspw. Abhängigkeiten haben. Auch ist das Erstellen von vielen YAML Dateien (Deployment, Service, Ingress, etc.) etwas umständlich. Daher gibt es einen Package Manager für Anwendungen, die wir auf Kubernetes deployen können – dieser heißt Helm. Möchten wir eine Applikation installieren, reicht dafür ein einzelner Befehl aus.

Dafür müssen wir aber zunächst Helm installieren:

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

Danach können wir die Version prüfen:

helm version

Die Packages nennen sich „Helm Charts“. Hier gibt es bereits viele offizielle Packages. Auf dem ArtifactHUB findest du weitere Charts. Einen Chart kannst du einfach hiermit installieren:

helm install <package-name>

Für mehr Infos kannst du helm install --help aufrufen.

 

Fazit und weitere Raspberry Pi Kubernetes Anwendungsmöglichkeiten

Wir haben gesehen, wie einfach es ist ein komplettes Kubernetes Cluster mit wenigen Raspberry Pi’s zu bauen. Natürlich kann auch jeder andere Linux-Rechner mit ins Cluster aufgenommen werden. Dadurch können wir die Rechenlast aufteilen und können mehrere parallele Prozesse laufen lassen.

Neben dem hier dargestellten nginx Deployment, kannst du auch viele weitere Anwendungen in einem Kubernetes Cluster auf dem Raspberry Pi laufen lassen. Beispiele hierfür wären:

• Raspberry Pi Minecraft Server
• Pi-Hole – ein Werbeblocker für das gesamte Netzwerk
• Grafana – grafische Darstellung von Daten aus verschiedenen Quellen

Falls eine dieser Anwendungen (oder etwas ganz anderes) für dich interessant ist, oder ein Tutorial dazu gewünscht sein sollte, würde ich mich über einen Kommentar freuen.