Best-practice Kubernetes Cluster mit kubeadm

Kubernetes mal einfach

Zu Recht fragst du dich jetzt wohl: Sowas gibts? Ja, gibt es tatsächlich! kubeadm ist ein Toolkit, welches dir dabei hilft ein einfaches Kubernetes Cluster zu bootstrappen. Der Gedanke hinter kubeadm ist, dir ein Werkzeug an die Hand zu geben, mit dem du einfach und schnell ein minimal lauffähiges Cluster aufsetzen kannst. Minimal lauffähig heißt, dass keine zusätzlichen Add-ons von kubeadm abgedeckt werden, als jene die unbedingt notwendig sind um ein funktionierendes Cluster zu erstellen. Nice-to-have Add-ons wie ein Kubernetes Dashboard oder Cloud spezifische AddOns liegen dabei aber außerhalb des Scopes von kubeadm. Stattdessen eignet sich kubeadm sehr gut als Testumgebung für kleinere Anwendungen, als erster Einstieg in die Kubernetes Welt oder alle anderen Experimente. Auch wenn kubeadm gerade erst am Anfang steht, bleibt es spannend, ob sich die Kubernetes Welt in Zukunft ein bisschen User freundlicher wird.

Wenn du gerade erst den Start mit Kubernetes wagst, dann kann ich dir als Einstieg in die Container Orchestration Welt unseren Artikel Container as a Service an die Hand geben.

Was werden wir machen?

Dieses Tutorial ist eine schnelle Anleitung für ein lauffähiges best-practice Kubernetes-Cluster bestehend aus zwei Nodes, einem Master Node und einem Worker Node. Du kannst diesem Tutorial auch folgen, wenn du ein Cluster bestehend aus einer höheren Anzahl an Nodes aufbauen willst. Für das Cluster habe ich 2 Cloud Server mit CentOS Template in meinem gridscale Panel erstellt. Ob du dem Tutorial auf unseren gridscale Cloud Servern, deinem Linux-Laptop, einem physikalischem Server oder auf dem Raspberry Pi folgst, ist dabei nebensächlich. Als Betriebssytem kommt jedes deb/rpm kompatible OS infrage wie z.B. CentOS oder Ubuntu.

Hier ein paar vorab Details zu meinem Setup im gridscale Panel:

• Host kubeMaster1: CentOS 7, 4 Cores, 2GB Ram, 40 GB Storage
• Host kubeWorker1: CentOS 7, 2 Cores, 2GB Ram, 40 GB Storage

Vorbereitungen

Ausgangspunkt für das weitere Vorgehen sind 2 gridscale Cloud Server mit den Hostnamen kubeMaster1 und kubeWorker1. Betrieben werden meine beiden VPS mit CentOS 7, die Erstellung hat via gridscale Template nur wenige Sekunden gedauert. Für jeden deiner VPS solltest du min. 2 GB RAM und für den Master min. 2 CPU einplanen. Zudem müssen deine Cloud Server über ein Öffentliches oder privates Netzwerk erreichbar sein und Docker in Version v1.12 (wird offiziell empfohlen), v1.11, v1.13 oder 17.03 installiert haben.

Server Konfiguration:

Bevor wir zur eigentlichen Installation und der Erstellung des Clusters übergehen können, gibts weiteres vorzubereiten. Du musst die beiden neu erstellten CentOS Cloud Server konfigurieren und anschließend Docker in Version v1.12
installieren.

Auf der Anforderungsliste von kubeadm stehen folgende Punkte, um die sich im Vorfeld gekümmert werden muss. Dazu gehört:

• Eindeutiger Hostname, MAC Adresse und product_uuid für jede Node
• Einige Ports müssen freigegeben sein –mehr Infos findest du hier
• SWAP Partitionierung muss deaktiviert werden

1. Überprüfe, ob all deine Maschine über eindeutige Hostnamen, MAC Adressen und product_uuid verfügen. Um diesen Punkt musst du dich nicht weiter sorgen, wenn du dem Tutorial bei gridscale folgst.
2. Portfreigabe. Die CentOS Firewalld ist bei unserem gridscale Template per Default aktiviert. Wir müssen mindestens den Port für den Kubernetes API Server 6443 und den Port 10250 für die Kubelet API freigeben.

Hinweis: Für das Ausführen der nachfolgenden Kommandos benötigst du Root-Rechte.

Finde zunächst heraus welche Zones unter Firewalld aktiviert sind.

firewall-cmd --get-active-zones

Dann fügst du die beiden Ports permanent zu deiner Zone hinzu.

firewall-cmd --zone=public --add-port=6443/tcp --permanent

firewall-cmd --zone=public --add-port=10250/tcp --permanent

3. Fehlt noch das ausschalten von SWAP Partitionierung. Unter CentOS 7 / Ubuntu deaktivierst du SWAP mit:

swapoff -a

Docker installieren

Auf allen Nodes die deinem Cluster angehören –das heißt Master und Worker –musst du Docker installieren. Als Version wird v1.12 offiziell von Kubernetes empfohlen, die Versionen v1.11, v1.13 and 17.03 sind aber ebenfalls bekannt dafür gut zu funktionieren.

CentOS:

yum -y update
yum -y install yum-utils
yum-config-manager --add-repo https://yum.dockerproject.org/repo/main/centos/7
yum -y update
# yum search --showduplicates docker-engine
yum -y --nogpgcheck install docker-engine-1.12.6-1.el7.centos.x86_64

systemctl enable docker &&systemctl start docker

Ubuntu:

Über die Ubuntu repositories kannst du dir Docker in Version v1.13 auf Ubuntu laden.

apt-get update
apt-get install -y docker.io

kubeadm Toolkit installieren

In diesem Teil zeige ich dir, wie du das Toolkit bestehend aus kubeadm, kubelet und kubectl auf CentOS sowie Ubuntu installierst. Du musst das Paket auf jeder deiner Maschinen die das Cluster bilden installieren.

Tipp: Mit der Snapshot Funktion gridscale kannst du dir Arbeit sparen. Erstelle einfach einen Snapshot nachdem du den ersten Host mit dem Toolkit ausgestattet hast und clone aus diesem Snap alle weiteren Hosts für dein Cluster.

Unter CentOS, REHL, Fedora
nutzt du zur Installation folgende Befehlen:

cat </etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF
setenforce 0
yum install -y kubelet kubeadm kubectl
systemctl enable kubelet && systemctl start kubelet

Hinweis: Damit die Container Zugriff auf das Host Filesystem haben, musst du unter
CentOS SELinux in den enforcing mode bringen.

setenforce 1

Setze jetzt noch /proc/sys/net/bridge/bridge-nf-call-iptables auf den Wert 1. Je nachdem welches Pod Network du später deployest, ist es Vorraussetzung diesen Wert anzupassen, damit dein Pod Network rund läuft. So auch bei Flannel, dem Pod Network welches wir später installieren. Mehr dazu kannst du hier lesen.

cat </etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl --system

kubeadm Installation unter Ubuntu/Debian

Unter Ubuntu fallen die Befehle etwas kürzer aus als bei CentOS:

apt-get update &&apt-get install -y apt-transport-https curl
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
cat </etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
apt-get update
apt-get install -y kubelet kubeadm kubectl

cgroup Driver konfigurieren

Dein cgroup Driver, der durch Kubelet genutzt wird, muss mit dem cgroup Driver von Docker übereinstimmen.

Mit

docker info | grep -i cgroup

wird dir ein Docker cgroup Driver ausgegeben. Und mit dem Befehl

cat /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

die Kubelet Konfiguration. In der Spalte mit dem Flag “–cgroup-driver=
” kannst du die Einstellung einsehen.

Falls deine Kubelet Konfiguration nicht übereinstimmt, kannst du in der Datei /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

das cgroup Flag entsprechend anpassen.

Bei meiner Installation von Docker v.1.12 und kubeadm unter CentOS 7, war der Docker cgroup Driver mit cgroupfs angegeben und bei Kubelet mit systemd. Falls bei dir genauso ist, kannst du die kubelet Config mit folgendem Befehl auf cgroupfs angleichen:

sed -i "s/cgroup-driver=systemd/cgroup-driver=cgroupfs/g" /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

Wenn eine Anpassung stattgefunden hat, muss dein Kubelet neugestartet werden.

systemctl daemon-reload

systemctl restart kubelet

Cluster erstellen mit kubeadm

An diesem Punkt des Tutorials solltest du auf beiden Cloud Servern alle Vorkonfigurationen abgeschlossen haben, sowie Docker und das kubeadm Toolkit erfolgreich installiert haben.

Master initialisieren

Initialisiere deinen Master:

kubeadm init --pod-network-cidr=10.244.0.0/16

Der Vorgang kann ein bisschen dauern… Zuerst werden eine Reihe von Pre-Checks gefahren, die sicherstellen sollen, dass dein Server bereit ist mit Kubernetes zu laufen. Während des Prozesses werden zudem Warnungen angezeigt und für den Fall, dass irgendwelche Errors auftreten wird der Prozess abgebrochen.

Wenn alles geklappt hat, sollte es in etwa so bei dir ausschauen:

Wie du sehen kannst, wird dir ein kubeadm join Befehl zurückgegeben mit dem du weitere Maschinen zu deinem Cluster hinzufügen kannst. Diesen wirst du später noch brauchen!

Danach kannst du als normaler Systembenutzer ohne Root-Rechte diesen Befehl ausführen um dein Cluster zu benutzen:

mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Deine mit dem init Befehl generierte admin.conf wird zu deinem HOME Verzeichnis hinzugefügt. Falls du weiterhin unter Root folgen willst, kannst du den Befehl auch einfach wiederholt vor den weiteren Befehlen ausführen. Andernfalls wird folgender Fehler auftreten:
“The connection to the server localhost:8080 was refused –did you specify the right host or port?”

---

Pod Network für das Cluster deployen

Ein sogenanntes Pod Network oder Container Network Interface ist notwendig, damit deine Pods untereinander kommunizieren können.

Bevor du mit kubeadm dein Cluster bootstrappen und anschließend eine Anwendung deployen kannst, muss dieses als Add-On auf der Master Maschine installiert werden.
Im weiteren Verlauf wählen wir für unser Cluster Flannel.

Das Standard Network kubenet hat einige Limitierungen und nicht sehr viele Features. Es gibt eine Vielzahl an Projekten die Alternativen für unterschiedliche Anwendungsfälle mit breitem Feature-Angebot liefern. Die 3 am häufigsten genutzten Provider sind Weave, Flannel und Calico. Flannel nutzt die Kubernetes API und als Network Model vxlan. Es ist ein einfach aufgebauter Provider der leicht zu konfigurieren ist und sehr viele User hat.

Nutze folgenden Befehl um Flannel über kubectl zu installieren:

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.9.1/Documentation/kube-flannel.yml

Damit das Flannel Pod Network richtig funktionieren kann, hast du zuvor das Flag

–pod-network-cidr=10.244.0.0/16
an den kubeadm init Befehl gehangen.

---

Worker hinzufügen

Wie du sicher schon bemerkt hast, wurde dir beim boostrappen des Clusters ebenfalls ein Befehl zurückgegeben mit dem du weitere Nodes zu deinem Cluster hinzufügen kannst.

Wechsel nun auf den Host, der deinem Cluster beitreten soll und den du zu Beginn des Tutorials ebenfalls vorbereitet und mit Docker und kubeadm ausgestattet hast. In meinem Fall mit dem Hostnamen kubeWorker1.

Hier führst du den kompletten zuvor mit init generierten Befehl kubeadm join, gefolgt von IP-Adresse und Token/Hash, aus.

Wenn alles glatt läuft bekommst du ein “This node has joined the cluster” zurück.

kubeadm join [deine-ip+token+hash]

Den gleichen Befehl verwendest du auf allen weiteren Hosts, die deinem Cluster beitreten sollen, falls du ein Cluster mit einer größeren Anzahl an Nodes planst.

Dein Kubernetes Cluster

…ist an dieser Stelle ready 🙂

Zurück auf dem Host kubeMaster1, kannst du jetzt dein fertiges Kubernetes Cluster bestaunen.

kubectl get nodes

Das Kubernetes Cluster besteht aus 2 Nodes, kubeMaster1 mit der Role Master und kubeWorker1 mit der Role .

Lass dich nicht von dem Role Status irritieren, kubeadm ist derzeit noch nicht vollständig entwickelt, es existiert hierzu aber bereits ein Thema auf GitHub.

Für alle weiteren Hürden und Probleme rund um kubeadm kannst du in das offizielle Troubleshooting von Kubernetes schauen:

https://kubernetes.io/docs/setup/independent/troubleshooting-kubeadm/

& bei Fragen oder Anregungen zu diesem oder einem anderen Tutorial freuen wir uns über Post von dir team@gridscale.io

---

Fazit

Die Kubernetes Welt ist komplex, groß und vor allem oft nicht ganz so einfach. Diese Komplexität ein wenig aus zu bremsen, ist der Ansatz hinter kubeadm. kubeadm verbessert die User-Experience mit Kubernetes und hat den Vorteil das es überall läuft –sogar auf dem Raspberry Pi. Ich hoffe, ich konnte dir und allen Kubernetes Neulingen da draußen in diesem Tutorial zeigen, wie du unter CentOS / Ubuntu ein kleines und sicheres Cluster mit kubeadm aufbaust. kubeadm eignet sich perfekt für weitere Experimente und um weiter in die Kubernetes Welt abzutauchen. Mehr folgt bald 🙂