Kubernetes, auch als k8s bekannt, ist eine Open-Source- und portable Container-Orchestrierungsplattform zur Automatisierung der Bereitstellung und Verwaltung von containerisierten Anwendungen. Kubernetes wurde ursprünglich von Google in der Programmiersprache Go entwickelt. Derzeit wird es von der Cloud Native Computing Foundation verwaltet.
In diesem Leitfaden führen wir Sie Schritt für Schritt durch die Installation eines Kubernetes-Clusters auf RHEL 8. Wir demonstrieren dies anhand eines Master- und eines Worker-Knotens, die wir unserem Cluster hinzufügen werden.
Lab-Setup
- Master-Knoten: master-node-k8 10.128.15.228
- Worker-Knoten: worker-node-1-k8 10.128.15.230
HINWEIS:Die Schritte 1 bis 6 sollten sowohl auf den Master- als auch auf den Worker-Knoten angewendet werden.
Schritt 1) Swap Space deaktivieren
Für eine optimale Leistung erfordert Kubernetes, dass Swap auf dem Hostsystem deaktiviert ist. Dies liegt daran, dass das Auslagern von Speicher erheblich zu Instabilität und Leistungseinbußen führen kann.
Um den Auslagerungsbereich zu deaktivieren, führen Sie den folgenden Befehl aus:
$ sudo swapoff -a
Um die Änderungen dauerhaft zu machen, bearbeiten Sie die Datei /etc/fstab und entfernen oder kommentieren Sie die Zeile mit dem Swap-Eintrag aus und speichern Sie die Änderungen.
Schritt 2) SELinux deaktivieren
Außerdem müssen wir SELinux deaktivieren und auf „permissiv“ setzen, um eine reibungslose Kommunikation zwischen den Knoten und den Pods zu ermöglichen.
Öffnen Sie dazu die SELinux-Konfigurationsdatei.
$ sudo vi /etc/selinux/config
Ändern Sie den SELINUX-Wert von erzwingend auf permissiv.
SELINUX=permissiv
Alternativ verwenden Sie den sed-Befehl wie folgt.
$ sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
Schritt 3) Konfigurieren Sie das Netzwerk im Master- und Worker-Knoten
Damit Ihre Master- und Worker-Knoten effektiv kommunizieren können, ist eine zusätzliche Netzwerkkonfiguration erforderlich. Bearbeiten Sie auf jedem Knoten die Datei /etc/hosts.
$ sudo vi /etc/hosts
Als nächstes aktualisieren Sie die Einträge wie gezeigt
10.128.15.228 master-node-k8 // Für den Master-Knoten10.128.15.230 worker-node-1-k8 // Für den Worker-Knoten
Speichern und beenden Sie die Konfigurationsdatei. Installieren Sie als Nächstes das Verkehrssteuerungs-Dienstprogrammpaket:
$ sudo dnf install -y iproute-tc
Schritt 4) Firewallregeln für k8s zulassen
Für eine nahtlose Kommunikation zwischen Master- und Worker-Knoten müssen Sie die Firewall konfigurieren und einige relevante Ports und Dienste zulassen, wie unten beschrieben.
Erlauben Sie auf dem Master-Knoten die folgenden Ports,
$ sudo firewall-cmd --permanent --add-port=6443/tcp$ sudo firewall-cmd --permanent --add-port=2379-2380/tcp$ sudo firewall-cmd --permanent --add -port=10250/tcp$ sudo firewall-cmd --permanent --add-port=10251/tcp$ sudo firewall-cmd --permanent --add-port=10252/tcp$ sudo firewall-cmd --reloadErlauben Sie auf dem Worker-Knoten die folgenden Ports,
$ sudo firewall-cmd --permanent --add-port=10250/tcp$ sudo firewall-cmd --permanent --add-port=30000-32767/tcp $ sudo firewall-cmd --reload>Schritt 5) CRI-O-Containerlaufzeit installieren
Kubernetes erfordert eine Containerlaufzeit, damit Pods ausgeführt werden können. Kubernetes 1.23 und höhere Versionen erfordern, dass Sie eine Containerlaufzeit installieren, die mit der Containerlaufzeitschnittstelle bestätigt wird.
Eine Container Runtime ist eine Anwendung, die das Ausführen von Containern unterstützt. Kubernetes unterstützt die folgende Container Runtime:
- Containerd
- CRI-O
- Docker-Engine
- Mirantis-Containerlaufzeit
In diesem Handbuch installieren wir CRI-O, eine High-Level-Container-Laufzeitumgebung. Dazu müssen wir zwei entscheidende Kernel-Module aktivieren – Overlay- und br_netfilter-Module.
Um dies zu erreichen, müssen wir die Voraussetzungen wie folgt konfigurieren:
Erstellen Sie zunächst eine Modulkonfigurationsdatei für Kubernetes.
$ sudo vi /etc/modules-load.d/k8s.conf
Fügen Sie diese Zeilen hinzu und speichern Sie die Änderungen
overlaybr_netfilter
Laden Sie dann beide Module mit dem Befehl modprobe.
$ sudo modprobe overlay$ sudo modprobe br_netfilter
Als nächstes konfigurieren Sie die erforderlichen sysctl-Parameter wie folgt
$ sudo vi /etc/sysctl.d/k8s.conf
Fügen Sie die folgenden Zeilen hinzu:
net.bridge.bridge-nf-call-iptables =1net.ipv4.ip_forward =1net.bridge.bridge-nf-call-ip6tables =1
Speichern Sie die Änderungen und beenden Sie. Um zu bestätigen, dass die Änderungen übernommen wurden, führen Sie den folgenden Befehl aus:
$ sudo sysctl --system
Um CRI-O zu installieren, stellen Sie die Umgebungsvariable $VERSION so ein, dass sie mit Ihrer CRI-O-Version übereinstimmt. Um zum Beispiel CRI-O Version 1.21 zu installieren, stellen Sie die $VERSION wie gezeigt ein:
$ export VERSION=1.21
Führen Sie als Nächstes die folgenden Befehle aus:
$ sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable /CentOS_8/devel:kubic:libcontainers:stable.repo
$ sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.repo https://download.opensuse.org/repositories/devel:kubic :libcontainers:stable:cri-o:$VERSION/CentOS_8/devel:kubic:libcontainers:stable:cri-o:$VERSION.repo
Verwenden Sie dann den DNF-Paketmanager, um CRI-O zu installieren:
$ sudo dnf install cri-o
Aktivieren Sie als Nächstes CRI-O beim Booten und starten Sie es:
$ sudo systemctl enable cri-o$ sudo systemctl start cri-o
Schritt 6) Kubernetes-Pakete installieren
Nachdem alles installiert ist, was für Kubernetes erforderlich ist, können wir fortfahren und Kubernetes-Pakete wie kubelet, kubeadm und kubectl installieren. Erstellen Sie eine Kubernetes-Repository-Datei.
$ sudo vi /etc/yum.repos.d/kubernetes.repo
Und fügen Sie die folgenden Zeilen hinzu.
[kubernetes]name=Kubernetesbaseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64enabled=1gpgcheck=1repo_gpgcheck=1gpgkey=https://packages.cloud.google.com/ yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpgexclude=kubelet kubeadm kubectl
Speichern Sie die Änderungen und beenden Sie. Schließlich installieren Sie das k8s-Paket wie folgt.
$ sudo dnf install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
Achten Sie nach der Installation darauf, den Kubelet-Dienst zu aktivieren und zu starten.
$ sudo systemctl enable kubelet$ sudo systemctl start kubelet
An dieser Stelle sind wir bereit, den Kubernetes-Cluster zu installieren.
Schritt 7) Erstellen Sie einen Kubernetes-Cluster
Wir werden einen Kubernetes-Cluster mit dem Befehl kubeadm wie folgt initialisieren. Dadurch wird eine Steuerungsebene im Master-Knoten initialisiert.
$ sudo kubeadm init --pod-network-cidr=192.168.10.0/16
Nachdem die Steuerungsebene erstellt wurde, müssen Sie einige zusätzliche Befehle ausführen, um mit der Verwendung des Clusters zu beginnen.
Führen Sie daher die Befehle nacheinander aus.
$ mkdir -p $HOME/.kube$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config$ sudo chown $(id -u):$(id -g) $HOME /.kube/config
Ganz am Ende der Ausgabe erhalten Sie den Befehl, auf Worker-Knoten auszuführen, um dem Cluster beizutreten. Dazu kommen wir später im nächsten Schritt.
Achten Sie auch darauf, Taints vom Master-Knoten zu entfernen:
$ kubectl taint nodes –all node-role.kubernetes.io/master-
Schritt 8) Calico Pod Network Add-on installieren
Der nächste Schritt ist die Installation von Calico CNI (Container Network Interface). Es ist ein Open-Source-Projekt, das verwendet wird, um Container-Netzwerke und -Sicherheit bereitzustellen. Nach der Installation von Calico CNI ändert sich der Status der Knoten in den Status „Bereit“, der DNS-Dienst innerhalb des Clusters wäre funktionsfähig und die Container können beginnen, miteinander zu kommunizieren.
Calico bietet Skalierbarkeit, hohe Leistung und Interoperabilität mit bestehenden Kubernetes-Workloads. Es kann vor Ort und auf gängigen Cloud-Technologien wie Google Cloud, AWS und Azure bereitgestellt werden.
Um Calico CNI zu installieren, führen Sie den folgenden Befehl vom Master-Knoten
aus$ kubectl create -f https://docs.projectcalico.org/manifests/tigera-operator.yaml
Wenn Sie fertig sind, führen Sie dieses aus.
$ kubectl create -f https://docs.projectcalico.org/manifests/custom-resources.yaml
Führen Sie den folgenden Befehl aus, um zu bestätigen, ob die Pods gestartet wurden:
$ watch kubectl get pods -n calico-system
Sie sollten sehen, dass jeder Pod „BEREIT“ ist und den Status „LÄUFT“ hat, wie in der dritten Spalte gezeigt.
Führen Sie den folgenden Befehl aus, um die Verfügbarkeit des Master-Knotens im Cluster zu überprüfen:
$ kubectl erhält Knoten
Darüber hinaus können Sie mit den -o wide-Optionen weitere Informationen abrufen.
$ kubectl get nodes -o wide
Die obige Ausgabe bestätigt, dass der Master-Knoten bereit ist. Außerdem können Sie die Pod-Namespaces überprüfen:
$ kubectl get pods --all-namespaces
Schritt 9) Worker-Knoten zum Cluster hinzufügen
Führen Sie zum Hinzufügen des Worker-Knotens zum Kubernetes-Cluster Schritt 1 bis Schritt 6 aus. Führen Sie anschließend den vom Master-Knoten generierten Befehl aus, um einen Worker-Knoten zum Cluster hinzuzufügen. In unserem Fall ist dies:
$ sudo kubeadm join 10.128.15.228:6443 --token cqb8vy.iicmmqrb1m8u9cob --discovery-token-ca-cert-hash sha256:79748a56f603e6cc57f67bf90b7db5aebe090107d540d6cc8a8f65b78.43de>
Wenn alles gut geht, sollten Sie die Benachrichtigung erhalten, dass der Knoten dem Cluster beigetreten ist. Wiederholen Sie denselben Vorgang für andere Knoten, falls Sie mehrere Worker-Knoten haben
Gehen Sie jetzt zurück zum Master-Knoten und überprüfen Sie noch einmal die Knoten in Ihrem Cluster. Dieses Mal erscheint der Worker-Knoten in der Liste der Knoten im Cluster,
$ kubectl erhält Knoten
Schlussfolgerung
Das war eine Anleitung, wie Sie einen Kubernetes-Cluster auf RHEL 8 installieren können. Ihr Feedback zu diesem Leitfaden ist willkommen.