Kubernetes Cluster mit Kubeadm auf Debian 11 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:
- Einrichten der Systeme, d.h. Einrichten der Datei /etc/hosts, Aktivieren der Kernel-Module und Deaktivieren von SWAP.
- Einrichten der UFW-Firewall durch Hinzufügen einiger Ports, die für Kubernetes und das CNI-Plugin (Calico) benötigt werden.
- Installation von CRI-O als Container-Laufzeitumgebung für Kubernetes.
- Installieren von Kubernetes-Paketen wie kubelet, kubeadm und kubectl.
- Initialisierung eines Control-Plane Nodes und Hinzufügen von zwei Worker Nodes.
Voraussetzungen
Um dieses Tutorial zu absolvieren, brauchst du die folgenden Voraussetzungen:
- Drei oder mehr Debian 11 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. Du wirst eine UFW-Firewall für die Kubernetes Control-Plane, den Worker-Node und das CNI-Plugin Calico einrichten.
- Aktiviere die 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 -------------------------------------------- k8s-master 192.168.5.10 control-plane k8s-worker1 192.168.5.115 worker node k8s-worker2 192.168.5.116 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 auf„k8s-master“ zu setzen.
sudo hostnamectl set-hostname k8s-master
Für die Kubernetes Worker Nodes führst du den folgenden hostnamectl-Befehl aus.
# setup hostname k8s-worker1 sudo hostnamectl set-hostname k8s-worker1
# setup hostname k8s-worker2
sudo hostnamectl set-hostname k8s-worker2
Als nächstes bearbeitest 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 k8s-master 192.168.5.115 k8s-worker1 192.168.5.116 k8s-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 k8s-master -c3 ping k8s-worker1 ping k8s-worker2 -c3
UFW-Firewall einrichten
Für Kubernetes müssen einige Ports auf allen deinen Systemen geöffnet sein. Auf dem Standard-Ubuntu-System wird die UFW-Firewall als Standard-Firewall verwendet. Du installierst die UFW-Firewall auf all deinen Debian-Systemen und fügst einige UFW-Regeln für den Kubernetes-Einsatz hinzu.
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
In diesem Beispiel werden wir Calico als CNI (Container Network Interface) Plugin verwenden. Daher wirst du im Folgenden einige zusätzliche Ports öffnen:
Protocol Direction Port Range Purpose Used By ------------------------------------------------------- TCP Bidirectional 179 Calico networking (BGP) UDP Bidirectional 4789 Calico networking with VXLAN enabled TCP Incoming 2379 etcd datastore UDP Bidirectional 4789 flannel networking (VXLAN)
Installiere das UFW-Paket auf deinen Debian-Servern mit dem folgenden apt-Befehl. Gib Y ein, um die Installation zu bestätigen und drücke ENTER, damit die Installation beginnt.
sudo apt install ufw
Als nächstes fügst du die OpenSSH-Anwendung mit dem folgenden Befehl zu deiner Firewall hinzu. 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
Führe auf dem Control-Plane-Knoten„k8s-master“ den folgenden ufw-Befehl aus, um Ports zu öffnen. Überprüfe und verifiziere dann die UFW-Regeln.
Firewall-Regeln für die Kubernetes Control-Plane.
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
Firewall-Regeln für das Calico CNI-Plugin.
sudo ufw allow 179/tcp sudo ufw allow 4789/udp sudo ufw allow 4789/tcp sudo ufw allow 2379/tcp
sudo ufw status
Auf den Worker Nodes„k8s-worker1“ und„k8s-worker2“ öffnest du mit dem folgenden ufw-Befehl einige Ports. Überprüfe dann die UFW-Firewall-Regeln.
Firewall-Regeln für Kubernetes Worker Nodes.
sudo ufw allow 10250/tcp sudo ufw allow 30000:32767/tcp
Firewall-Regeln für Calico auf Kubernetes Worker Nodes.
sudo ufw allow 179/tcp sudo ufw allow 4789/udp sudo ufw allow 4789/tcp sudo ufw allow 2379/tcp
sudo ufw status
Aktiviere Kernel-Module und deaktiviere SWAP
Für die Kubernetes müssen die Kernel-Module „overlay“ und „br_netfilter“ auf allen Servern aktiviert werden. 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“ mit dem folgenden Befehl. Dadurch können Linux-Systeme die Kernel-Module 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 sysctl-Befehl. Du solltest die Liste der standardmäßigen sysctl params auf deinem System erhalten und sicherstellen, dass du die sysctl params erhältst, die du gerade in der Datei„k8s.conf“ hinzugefügt hast.
sudo sysctl --system
Um SWAP zu deaktivieren, musst du die SWAP-Konfiguration in der Datei„/etc/fstab“ auskommentieren. Das kannst du mit dem einfachen Befehl über sed (Stream-Editor) oder durch manuelles Bearbeiten der Datei /etc/fstab machen.
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
oder
sudo nano /etc/fstab
Als Nächstes schaltest du den 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: CRI-O
Um Kubernetes Cluster einzurichten, musst du die Container-Runtime 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 „CRI-O“ als Container für unser Kubernetes-Deployment verwenden. Du wirst CRI-O also auf allen Servern, der Control-Plane und den Worker Nodes installieren.
Bevor du CRI-O installierst, führe den folgenden apt-Befehl aus, um das Basispaket„gnupg2“ und„apt-transport-https“ zu installieren. Gib Y ein, um die Installation zu bestätigen und drücke ENTER.
sudo apt install gnupg2 apt-transport-https
Erstelle nun eine neue Umgebungsvariable für die CRI-O-Installation. Die Variable „$OS“ mit dem Wert „Debian_11“ und die Variable „$VERSION“ mit dem Wert „1.24“. In diesem Beispiel werden wir den CRI-O Container v1.24 (aktuelle Version) für „Debian_11“ Systeme installieren.
export OS=Debian_11 export VERSION=1.24
Führe den folgenden Befehl aus, um das CRI-O Repository für das Debian 11 System hinzuzufügen.
echo "deb [signed-by=/usr/share/keyrings/libcontainers-archive-keyring.gpg] https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list echo "deb [signed-by=/usr/share/keyrings/libcontainers-crio-archive-keyring.gpg] https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.list
Führe den folgenden Befehl aus, um den GPG-Schlüssel für das CRI-O-Repository hinzuzufügen.
mkdir -p /usr/share/keyrings curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | gpg --dearmor -o /usr/share/keyrings/libcontainers-archive-keyring.gpg curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/Release.key | gpg --dearmor -o /usr/share/keyrings/libcontainers-crio-archive-keyring.gpg
Aktualisiere nun die System-Repositories und aktualisiere den Paketindex mit dem folgenden Befehl. Du solltest sehen, dass das CRI-O Repository zu den Debian 11 Servern hinzugefügt wurde.
sudo apt update
Um die CRI-O Container-Runtime zu installieren, führe den folgenden apt-Befehl aus. Gib Y ein, um die Installation zu bestätigen, und drücke ENTER, damit die Installation von CRI-O beginnt.
sudo apt install cri-o cri-o-runc cri-tools
Nachdem die Installation abgeschlossen ist, bearbeite die CRI-O-Konfiguration „/etc/crio/crio.conf“ mit dem folgenden Befehl.
sudo nano /etc/crio/crio.conf
Entferne im Abschnitt „[crio.network]“ die Kommentare zu den Optionen„network_dir“ und„plugin_dir„.
# The crio.network table containers settings pertaining to the management of # CNI plugins. [crio.network]
# The default CNI network name to be selected. If not set or „“, then
# CRI-O will pick-up the first one found in network_dir.
# cni_default_network = „“
# Path to the directory where CNI configuration files are located.
network_dir = „/etc/cni/net.d/“
# Paths to directories where CNI plugin binaries are located.
plugin_dirs = [
„/opt/cni/bin/“,
]
Wenn du fertig bist, speichere und schließe die Datei.
Als Nächstes bearbeitest du die CRI-O-Bridge-Konfiguration„/etc/cni/net.d/100-crio-bridge.conf“ mit dem folgenden Befehl.
sudo nano /etc/cni/net.d/100-crio-bridge.conf
Ändere das Standard-Subnetz der IP-Adresse durch dein eigenes Subnetz. Diese Subnetz-IP-Adresse wird für deine Pods im Kubernetes-Cluster verwendet. Außerdem musst du sicherstellen, dass die IP-Adresse des Subnetzes mit der IP-Adresskonfiguration des CNI-Plugins übereinstimmt.
In diesem Beispiel verwenden wir die Subnetz-IP-Adresse„10.42.0.0/24“ für Pods im Kubernetes-Cluster.
...
"ranges": [
[{ "subnet": "10.42.0.0/24" }],
[{ "subnet": "1100:200::/24" }]
]
...
Speichere und schließe die Datei, wenn du fertig bist.
Als Nächstes führst du den folgenden systemctl-Befehl aus, um den CRI-O-Dienst neu zu starten und die neuen Änderungen zu übernehmen.
sudo systemctl restart crio
Zuletzt aktivierst du den CRI-O-Dienst, damit er beim Systemstart ausgeführt wird. Überprüfe dann den Status des CRI-O-Dienstes. Du solltest sehen, dass der CRI-O-Dienst aktiviert ist und der aktuelle Status „running“ lautet.
sudo systemctl enable crio sudo systemctl status crio
Installation der Kubernetes-Pakete
Du hast die CRI-O Container-Laufzeitumgebung installiert. Jetzt installierst du die Kubernetes-Pakete auf allen deinen Debian-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. Du fügst also das Kubernetes-Repository zu allen deinen Debian-Systemen hinzu.
Führe den folgenden Befehl aus, um das Kubernetes-Repository und den GPG-Schlüssel hinzuzufügen.
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, damit 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 es zu Versionsunterschieden zwischen den Kubernetes-Paketen kommt.
sudo apt-mark hold kubelet kubeadm kubectl
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 „k8s-master“ 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 Befehl„crictl“ aus, um die Liste der verfügbaren Images auf dem „k8s-master“-Server zu überprüfen. Du solltest die Liste der Images sehen, die für die Erstellung des Kubernetes-Clusters verwendet werden sollen.
sudo crictl images
Als Nächstes führst du den Befehl „kubeadm init“ aus, um den Kubernetes Cluster auf dem „k8s-master“-Server zu initialisieren. Dieser Knoten „k8s-master“ wird automatisch als Kubernetes Control Plane ausgewählt, da dies die erste Initialisierung des Clusters ist.
Außerdem legen wir in diesem Beispiel das Netzwerk für Pods auf„10.42.0.0/24“ fest, was dasselbe Subnetz ist wie die CRI-O-Bridge-Konfiguration „/etc/cni/net.d/100-crio-bridge.conf“.
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 zum CRI-O-Container-Runtime-Socket an, der auf„/var/run/crio/crio.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 Container Runtime-Socket automatisch erkennt.
sudo kubeadm init --pod-network-cidr=10.42.0.0/24 \ --apiserver-advertise-address=192.168.5.10 \ --cri-socket=unix:///var/run/crio/crio.sock
Unten siehst du die Ausgabe, wenn du den Kubernetes Cluster auf dem„k8s-master“ Server initialisierst.
Wenn die Initialisierung abgeschlossen ist, siehst du die Meldung „Your Kubernetes control-plane has initialized successfully!“ mit einigen wichtigen Ausgabemeldungen zum Einrichten der Kubernetes-Anmeldeinformationen und zum Deployment des Pod-Netzwerk-Add-ons sowie zum Hinzufügen des Worker Nodes zu deinem Kubernetes Cluster.
Bevor du mit der Verwaltung des Kubernetes-Clusters mit dem Tool „kubectl“ beginnst, 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 Kubernetes läuft, richtest du das Calico CNI Plugin für deinen Kubernetes Cluster ein. Führe den folgenden Befehl aus, um die Calico-Manifestdatei„calico.yaml“ herunterzuladen. Bearbeite dann die Datei„calico.yaml“ mit dem Editor nano.
curl https://docs.projectcalico.org/manifests/calico.yaml -O nano calico.yaml
Hebe den Kommentar in der Konfiguration„CALICO_IPV4POOL_CIDR“ auf und ändere das Netzwerk-Subnetz in„10.42.0.0/24„. Diese Subnetzkonfiguration muss das gleiche Subnetz sein wie in der CRI-O-Bridge-Konfiguration und der „–pod-network-cidr“-Konfiguration während der Kubernetes-Initialisierung mit dem Befehl „kubeadm init“.
... - name: CALICO_IPV4POOL_CIDR value: "10.42.0.0/24" ...
Wenn du fertig bist, speichere und schließe die Datei.
Als Nächstes führst du den Befehl „kubectl“ aus, um das Calico CNI Plugin mit der benutzerdefinierten Manifestdatei „calico.yaml“ bereitzustellen. Dieser Befehl erstellt mehrere Kubernetes-Ressourcen für das Calico CNI-Plugin. Außerdem werden damit Calico-Images heruntergeladen und neue Pods für Calico erstellt.
sudo kubectl apply -f calico.yml
Führe nun den folgenden kubectl-Befehl aus, um die verfügbaren Pods in deinem Kubernetes-Cluster zu überprüfen. Du solltest zwei zusätzliche Pods sehen: „calico-node-xxx“ und „calico-kube-controller-xxx“.
kubectl get pods --all-namespaces
Hinzufügen von Worker Nodes zu Kubernetes
Nachdem du die Kubernetes Control Plane auf dem „k8s-master“ Server initialisiert hast, fügst du die Worker Nodes„k8s-worker1“ und„k8s-worker2“ zum Kubernetes Cluster hinzu.
Gehe zum„k8s-worker1„-Server und führe den folgenden„kubeadm join„-Befehl aus, um den„k8s-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 dbgk8h.nwzqqp1v5aqif5fy \ --discovery-token-ca-cert-hash sha256:7a543a545585358b143ce3e8633a8d673b6f628c5abc995939a58606c6dd219c
In der folgenden Ausgabe kannst du sehen, dass der Server„k8s-worker1“ dem Kubernetes-Cluster beigetreten ist.
Als Nächstes gehst du zum Server„k8s-worker2“ und führst den Befehl„kubeadm join“ aus, um„k8s-worker2“ dem Kubernetes Cluster hinzuzufügen.
kubeadm join 192.168.5.10:6443 --token dbgk8h.nwzqqp1v5aqif5fy \ --discovery-token-ca-cert-hash sha256:7a543a545585358b143ce3e8633a8d673b6f628c5abc995939a58606c6dd219c
Wenn der Vorgang abgeschlossen ist, siehst du die gleiche Meldung.
Gehe nun zurück zum Control Plane Server „k8s-master“ und führe den folgenden Befehl aus, um alle laufenden Pods im Kubernetes Cluster zu überprüfen. Du solltest sehen, dass es zusätzliche Pods für jede Kubernetes-Komponente gibt.
kubectl get pods --all-namespaces
oder
kubectl get pods -o wide --all-namespaces
Überprüfe abschließend alle verfügbaren Knoten im Kubernetes Cluster mit dem Befehl „kubectl“. Du solltest sehen, dass der Server „cplane1“ als Kubernetes Control Plane und die Server „k8s-worker1“ und „k8s-worker2“ als Worker Nodes laufen.
kubectl get nodes -o wide
Nginx-Pod im Kubernetes-Cluster bereitstellen
Führe den folgenden Befehl aus, um ein neues Deployment für den Nginx-Webserver zu erstellen. In diesem Beispiel erstellen wir neue Nginx Pods basierend auf dem Image„nginx:alpine“ mit zwei Repliken.
kubectl create deployment nginx --image=nginx:alpine --replicas=2
Erstelle nun einen neuen Dienst vom Typ„NodePort„, der das Nginx-Deployment mit dem folgenden kubectl-Befehl bereitstellt. Dieser Befehl erstellt einen neuen Kubernetes-Dienst namens „nginx“ mit dem Typ„NodePort“ und stellt den Port„80“ für den Pod bereit.
kubectl create service nodeport nginx --tcp=80:80
Als nächstes führst du den folgenden kubectl-Befehl aus, um die Liste der laufenden Pods in deinem Kubernetes-Cluster zu überprüfen. Du solltest sehen, dass zwei Nginx-Pods laufen.
kubectl get pods
Überprüfe nun die Liste der verfügbaren Dienste in Kubernetes mit folgendem Befehl. Du solltest sehen, dass der Dienst„nginx“ vom Typ NodePort den Port„80“ und den Port „31277“ auf den Kubernetes-Hosts freigibt. Der Dienst NodePort stellt immer einen Port im Bereich 30000-32767 zur Verfügung.
kubectl get svc
Führe den folgenden curl-Befehl aus, um auf deinen Nginx-Einsatz zuzugreifen.
curl k8s-worker1:31277 curl k8s-worker2:31277
Unten siehst du die Ausgabe des index.html-Quellcodes vom Knoten„k8s-worker1„.
Und unten siehst du den index.html-Quellcode des Knotens„k8s-worker2„.
Fazit
In diesem Lernprogramm hast du die Einrichtung des Kubernetes-Clusters mit drei Knoten und Debian 11-Servern abgeschlossen. Der Kubernetes Cluster läuft mit einer Control Plane und zwei Worker Nodes. Er läuft mit CRI-O als Container-Laufzeitumgebung für deinen Kubernetes-Cluster und dem Calico CNI-Plugin für die Vernetzung von Pods in deinem Cluster. Außerdem hast du den Nginx-Webserver erfolgreich im Kubernetes-Cluster implementiert.
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.