So installieren Sie Kubernetes auf allen Linux-Distributionen

Kubernetes ist eine Container-Orchestrierungssoftware, die es uns ermöglicht, containerisierte Anwendungen über eine beliebige Anzahl von Knotensystemen hinweg bereitzustellen, zu verwalten und zu skalieren. Es handelt sich um eine leistungsstarke Open-Source-Technologie, die das Ausführen von Anwendungen in großem Maßstab erheblich effizienter macht und die traditionelle Art und Weise ersetzt, Anwendungen direkt auf dem Betriebssystem oder in einer virtuellen Maschine auszuführen. Ein Kubernetes-Cluster bietet auch Selbstheilung, Lastausgleich und die Möglichkeit, Hunderte oder Tausende von containerisierten Anwendungen über eine einzige Eingabeaufforderung zu verwalten.

In diesem Tutorial erfahren Sie, wie Sie Kubernetes auf allen wichtigen Linux-Distributionen installieren. Dies ist nicht so einfach wie die Installation der meisten Anwendungen, da die offiziellen Repositories in der Regel nicht die gesamte benötigte Software enthalten. Es ist auch wichtig, Docker (oder eine andere Containerisierungsschicht) zu installieren, Swap zu deaktivieren und einige andere Einstellungen zu konfigurieren. Wir werden Sie im Folgenden durch alles führen.

In diesem Tutorial lernen Sie:

So installieren Sie Kubernetes (kubeadm) auf allen wichtigen Linux-Distributionen
So installieren Sie Docker und kubectl
So deaktivieren Sie den Auslagerungsbereich
Starten und Aktivieren von Docker- und Kubelet-Diensten

Kubernetes-Installationstypen

Es ist nicht so einfach, einfache Anweisungen zur Installation von Kubernetes auf einem Linux-System zu geben, da es viele verschiedene Möglichkeiten gibt, es auszuführen. Es gibt mindestens vier verschiedene Technologien, die wir für den Einstieg in Kubernetes nutzen können:

Kubeadm
Minikube
Art
K3s

Jeder hat seine eigene Nische, Vor- und Nachteile. Derjenige, auf den wir uns in diesem Tutorial konzentrieren werden, ist Kubeadm, da es sich um eine produktionsfertige Implementierung von Kubernetes handelt. Für absolute Einsteiger ist es wenig geeignet, wenn man also Schwierigkeiten hat, es zum Laufen zu bringen, kann man auf eine einfachere Technologie wie Minikube zurückgreifen.

Die andere Option, die wir haben, ist die Wahl einer Containerisierungstechnologie. Kubernetes benötigt eines, um ausgeführt zu werden. Wir können aus Container-Laufzeiten wählen, wie z. B.:

Hafenarbeiter
containerd
CRI-O

Docker ist bei weitem die beliebteste Wahl, wenn es um eine Container-Runtime für Kubernetes geht, daher werden wir uns in diesem Tutorial darauf konzentrieren.

Wir werden auch separate Technologien wie kubectl separat installieren.

Installieren von Kubernetes (kubeadm) unter Linux

Wählen Sie in den folgenden Abschnitten Ihre Linux-Distribution aus und folgen Sie dann den entsprechenden Anweisungen.

Debian und Ubuntu

Dieser Abschnitt ist für Linux-Distributionen wie Debian Linux, Ubuntu Linux und jede ihrer vielen abgeleiteten Distributionen.

Deaktivieren Sie zunächst den Swap:
```
sudo swapoff -a
```
Sie müssen auch /etc/fstab bearbeiten und die Swap-Zeile kommentieren, um sie bei zukünftigen Neustarts zu deaktivieren.

Beginnen Sie mit der Installation der folgenden erforderlichen Pakete:


sudo apt update
sudo apt install docker.io apt-transport-https ca-certificates curl

Fügen Sie der Docker-Gruppe Ihren aktuellen Benutzer hinzu:
```
sudo usermod -a -G docker $USER
```
Nachdem die Installation von Docker abgeschlossen ist, verwenden Sie die folgenden Befehlsbefehle, um den Dienst zu starten und sicherzustellen, dass er nach jedem Neustart automatisch gestartet wird:
```
sudo systemctl start docker
sudo systemctl enable docker
```

Laden Sie den folgenden Signaturschlüssel herunter:


sudo curl -fsSLo /etc/apt/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg

Fügen Sie das Kubernetes-Software-Repository zu Ihrem System hinzu:


echo "deb [signed-by=/etc/apt/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Installieren Sie dann die Tools kubelet, kubeadm und kubectl:
```
sudo apt update
sudo apt install kubelet kubeadm kubectl
```
Optional können wir die Kubernetes-Pakete so markieren, dass sie von apt nicht aktualisiert werden, bis wir manuell versuchen, sie zu aktualisieren. Dadurch wird sichergestellt, dass Ihr Cluster nie durch Updates unterbrochen wird und dass eine neue Version Ihr aktuelles Setup nicht beeinträchtigt.
```
sudo apt-mark hold kubelet kubeadm kubectl
```

Fedora, Red Hat, CentOS, AlmaLinux, Rocky Linux

Dieser Abschnitt bezieht sich auf Red Hat Enterprise Linux, Fedora Linux und alle ihre abgeleiteten Distributionen.

Deaktivieren Sie zunächst den Swap:
```
sudo swapoff -a
```
Sie müssen auch /etc/fstab bearbeiten und die Swap-Zeile kommentieren, um sie bei zukünftigen Neustarts zu deaktivieren.
Beginnen Sie mit der Installation des Pakets dnf-plugins-core, falls es noch nicht auf Ihrem System vorhanden ist. Auf diese Weise können Sie Ihre dnf-Repositories verwalten und ihnen das offizielle Docker-Repository hinzufügen.
```
sudo dnf -y install dnf-plugins-core
```

Fügen Sie als Nächstes das Docker-Repository mit dem folgenden Befehl zu Ihrem System hinzu.


sudo dnf config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo

Bevor wir mit der Installation von Docker beginnen, müssen wir die podman- und buildah-Pakete von unserem System entfernen, da sie mit Docker in Konflikt stehen und die Installation verhindern.
```
sudo dnf remove podman buildah
```
Wir können nun die drei Docker-Pakete installieren, die wir benötigen, indem wir den folgenden Befehl ausführen.
```
sudo dnf install docker-ce docker-ce-cli containerd.io
```
Fügen Sie der Docker-Gruppe Ihren aktuellen Benutzer hinzu:
```
sudo usermod -a -G docker $USER
```
Sobald die Installation abgeschlossen ist, starten Sie den Docker-Dienst, und aktivieren Sie dann die automatische Ausführung bei jedem Neustart des Systems:
```
sudo systemctl start docker.service
sudo systemctl start containerd.service
sudo systemctl enable docker.service
sudo systemctl enable containerd.service
```

Fügen Sie das Kubernetes-Repository zu Ihrem System hinzu:


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/rpm-package-key.gpg
exclude=kubelet kubeadm kubectl
EOF

Deaktivieren Sie SELinux, indem Sie es in den permissiven Modus versetzen:


sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

Installieren Sie die Pakete kubelet, kubeadm und kubectl:


sudo dnf install -y kubelet kubeadm kubectl --disableexcludes=kubernetes

Weisen Sie systemd an, kubelet zu starten und es bei zukünftigen Systemstarts automatisch starten zu lassen:
```
sudo systemctl enable kubelet
sudo systemctl start kubelet
```

Arch Linux und Manjaro

Dieser Abschnitt gilt für Linux-Distributionen wie Arch Linux, Manjaro Linux und deren Derivate.

Deaktivieren Sie zunächst den Swap:
```
sudo swapoff -a
```
Sie müssen auch /etc/fstab bearbeiten und die Swap-Zeile kommentieren, um sie bei zukünftigen Neustarts zu deaktivieren.
Beginnen Sie mit der Installation von Docker (und yay, um Kubernetes vom AUR herunterzuladen):
```
sudo pacman -Syu
sudo pacman -S docker yay devtools base-devel
```
Fügen Sie der Docker-Gruppe Ihren aktuellen Benutzer hinzu:
```
sudo usermod -a -G docker $USER
```
Sobald die Installation abgeschlossen ist, starten Sie den Docker-Dienst, und aktivieren Sie ihn für die Ausführung bei jedem Neustart des Systems:
```
sudo systemctl start docker.service
sudo systemctl enable docker.service
```
Jetzt können wir yay verwenden, um kubeadm, kubelet und kubectl von der AUR herunterzuladen:
```
yay -S kubeadm-bin kubelet-bin kubectl-bin
```
Starten Sie abschließend den Kubelet-Dienst, damit Kubernetes einsatzbereit ist:
```
sudo systemctl start kubelet
sudo systemctl enable kubelet
```

Snap-Methode

Es ist auch möglich, den Snap-Paketmanager zu verwenden, um alle erforderlichen Kubernetes-Pakete zu installieren.

Installieren Sie Docker, kubeadm, kubectl und kubelet mit Snap:


sudo snap install docker
sudo snap install kubeadm kubectl kubelet --classic

Fügen Sie der Docker-Gruppe Ihren aktuellen Benutzer hinzu:
```
sudo usermod -a -G docker $USER
```

Und starten Sie die notwendigen Dienste:


sudo systemctl start docker
sudo systemctl enable docker
sudo systemctl start kubelet
sudo systemctl enable kubelet

Abschließende Gedanken

In diesem Tutorial haben wir gesehen, wie man Kubernetes in allen wichtigen Linux-Distributionen installiert, einschließlich einer universellen Methode über den Snap-Paketmanager. Diese Anweisungen reichen aus, um Ihnen den Einstieg in die Grundlagen zu erleichtern, zu denen auch die Installation von kubeadm und Docker gehört. Sobald Sie diese Dienste eingerichtet und ausgeführt haben, können Sie fortfahren, indem Sie Knoten beitreten, Anwendungen bereitstellen und Ihren Kubernetes-Cluster erweitern.