So installierst du KubeSphere unter Ubuntu 22.04

Kubesphere ist eine freie und quelloffene Kubernetes-Plattform und ein von der CNCF verifiziertes Cloud-natives Anwendungsmanagement. Es handelt sich um eine Kubernetes-Container-Plattform für Unternehmen mit vielen Funktionen, die auf den hybriden Multi-Cloud-Einsatz zugeschnitten ist. Kubesphere beinhaltet standardmäßig vollständig automatisierte IT-Operationen und ist mit DevOps-Workflows optimiert. Es kann auf einen bestehenden Kubernetes-Cluster oder eine Linux-Distribution aufgesetzt werden. Du kannst Kubesphere aber auch über KubeKey einrichten, ein Kommandozeilen-Tool für Linux, mit dem du Kubernetes-Cluster automatisch deployen, aktualisieren und skalieren kannst.

Kubesphere bietet ein intuitives grafisches Web-UI für die Verwaltung des Kubernetes-Clusters. Es enthält außerdem Plug-Ins für CI/CD-Tools wie Jenkins, mit denen du automatisch eine CI/CD-Pipeline einrichten kannst. Außerdem bietet es Source-to-Image (S2I) für die automatische Erstellung reproduzierbarer Container-Images aus dem Quellcode und Binary-to-Image (B2I) für die Erstellung reproduzierbarer Container-Images aus einer Binärdatei (Jar, War, Binary file).

Dieser Artikel führt dich durch die Implementierung von Kubernetes und Kubesphere auf Ubuntu 22.04 Servern. Du wirst mehrere Ubuntu-Server für diesen Einsatz verwenden und die KubeKey-Anwendung nutzen, die von Kubesphere für den automatischen Einsatz von Kubernetes-Cluster und Kubesphere bereitgestellt wird.

Voraussetzungen

Um dieses Tutorial durchzuführen, brauchst du die folgenden Voraussetzungen:

• Drei Linux-Server mit Ubuntu 22.04 – Du wirst einen Server als Kubernetes Control-Plane und zwei Server als Worker Nodes verwenden.
• Einen Nicht-Root-Benutzer mit sudo/root administrator pirivlges.

Hosts und Benutzer einrichten

Bevor du Kubernetes und Kubesphere installierst, musst du die Datei „/etc/hosts“ einrichten und einen neuen Benutzer mit sudo password-less auf allen deinen Servern anlegen. Deshalb musst du die folgenden Befehle auf allen deinen Ubuntu-Servern ausführen.

Öffne nun die Datei „/etc/hosts“ mit dem folgenden nano-Editor-Befehl.

sudo nano /etc/hosts

Füge die IP-Adressen der Server und den Hostnamen in die Datei ein.

192.168.5.35    master    master
192.168.5.121   node1     node1
192.168.5.122   node2     node2

Speichere die Datei und schließe den Editor, wenn du fertig bist.

Als Nächstes gibst du den folgenden Befehl ein, um einen neuen Benutzer namens „ubuntu“ zu erstellen und das Passwort für den neuen Benutzer„ubuntu“ festzulegen. Wenn du dazu aufgefordert wirst, gib dein Passwort ein und wiederhole es.

sudo useradd -m -s /bin/bash ubuntu
sudo passwd ubuntu

Zum Schluss gibst du den folgenden Befehl ein, damit der Benutzer „ubuntu“„sudo“ ohne Passwort ausführen kann. Der Benutzer „ubuntu“ wird für die Installation von Paketabhängigkeiten verwendet, daher musst du sicherstellen, dass der Benutzer ohne Passwort zu root werden kann.

cat <<EOF | sudo tee /etc/sudoers.d/ubuntu
Defaults:ubuntu !fqdn
Defaults:ubuntu !requiretty
ubuntu ALL=(ALL) NOPASSWD: ALL
EOF

Nachdem du die Datei „/etc/hosts“ konfiguriert und den Benutzer„ubuntu“ angelegt hast, richtest du als Nächstes die passwortlose SSH-Authentifizierung für den Benutzer„ubuntu“ ein.

SSH-Authentifizierung mit Schlüssel einrichten

In diesem Abschnitt richtest du eine passwortlose SSH-Authentifizierung für den Benutzer „ubuntu“ ein. Das Szenario für die Installation von Kubernetes und Kubesphre geht also vom„Master„-Server aus. Die Installation auf„node1“ und „node2“ wird automatisch durchgeführt.

Gib auf dem „Master“-Server den folgenden Befehl ein, um dich als Benutzer„ubuntu“ anzumelden. Erstelle dann mit dem Befehl„ssh-keygen“ ein neues SSH-Schlüsselpaar (siehe unten). Wenn du fertig bist, werden deine öffentlichen und privaten SSH-Schlüssel im Verzeichnis„~/.ssh“ gespeichert.

su - ubuntu
ssh-keygen -t ed25519

Als Nächstes gibst du den folgenden Befehl ein, um den öffentlichen SSH-Schlüssel vom „Master“-Server an alle Knoten zu senden, die für die Kubernetes- und Kubesphre-Installation verwendet werden sollen.

ssh-copy-id ubuntu@master
ssh-copy-id ubuntu@node1
ssh-copy-id ubuntu@node2

Gib„ja“ ein, um den SSH-Fingerprint für den Server zu akzeptieren, und gib dann das Passwort für den Benutzer„ubuntu“ ein, wenn du dazu aufgefordert wirst. Sobald der SSH-Schlüssel hinzugefügt wurde, solltest du eine Ausgabe wie„Anzahl der hinzugefügten Schlüssel: 1“ erhalten.

Unten siehst du eine Ausgabe, wenn du den öffentlichen SSH-Schlüssel zum localhost des„Master„-Servers hinzufügst.

Unten siehst du die Ausgabe, wenn du den öffentlichen SSH-Schlüssel zum Server„node1“ hinzufügst.

Unten siehst du die Ausgabe, wenn du den öffentlichen SSH-Schlüssel zum Server„node2“ hinzufügst.

Nachdem der öffentliche SSH-Schlüssel hinzugefügt und hochgeladen wurde, kannst du dich jetzt mit dem Benutzer „ubuntu“ ohne Passwortauthentifizierung mit all deinen Servern verbinden.

Im nächsten Abschnitt überprüfst du, ob du dich mit einem passwortlosen„ubuntu„-Benutzer mit allen Knoten/Servern verbinden kannst, und installierst dann einige Paketabhängigkeiten.

Installieren der Abhängigkeiten

Du hast also den öffentlichen SSH-Schlüssel vom„Master„-Server auf die beiden Server„node1“ und„node2“ hochgeladen. Jetzt stellst du sicher, dass du dich über den Benutzer „ubuntu“ mit einer passwortlosen SSH-Authentifizierung mit beiden Servern verbinden kannst und installierst die grundlegenden Abhängigkeiten für Kubernetes und Kubesphere.

Gib auf dem„Master„-Server den folgenden Befehl ein, um den Ubuntu-Paketindex zu aktualisieren und einige Paketabhängigkeiten über den unten stehenden Befehl„apt install“ zu installieren.

sudo apt update
sudo apt install curl socat conntrack ebtables ipset

ssh-keyscan -H master >> ~/.ssh/known_hosts

Wenn du dazu aufgefordert wirst, gibst du zur Bestätigung y ein und drückst ENTER, um fortzufahren.

Als Nächstes verbindest du dich mit dem Server„node1“ über den unten stehenden Befehl„ssh„. Nachdem der Befehl ausgeführt wurde, solltest du bei„node1“ ohne Passwortauthentifizierung eingeloggt sein.

ssh ubuntu@node1

Gib nun den folgenden apt-Befehl ein, um deinen Ubuntu-Paketindex zu aktualisieren und aufzufrischen. Installiere dann einige grundlegende Paketabhängigkeiten. Gib y ein, wenn du dazu aufgefordert wirst, und drücke ENTER, um fortzufahren.

sudo apt update
sudo apt install curl socat conntrack ebtables ipset

Zuletzt verbindest du dich mit dem Server„node2“ über den unten stehenden„ssh„-Befehl.

ssh ubuntu@node2

Sobald du verbunden bist, gibst du den folgenden Befehl ein, um den Paketindex des Repositorys zu aktualisieren. Dann installierst du einige Paketabhängigkeiten mit dem Befehl„apt install„.

sudo apt update
sudo apt install curl socat conntrack ebtables ipset

Gib y ein, wenn du dazu aufgefordert wirst und drücke ENTER, um fortzufahren.

Jetzt hast du deine Server für die Installation von Kubernetes und Kubesphre konfiguriert. Im nächsten Abschnitt lädst du die Binärdatei von KubeKey herunter, die für die Initialisierung des Kubernetes-Clusters und die Installation von Kubesphere benötigt wird.

Herunterladen von KubeKey auf dem Master-Knoten

In diesem Abschnitt lädst du die KubeKey-Binärdatei auf den „Master“-Server herunter. Der KubeKey ist eine einzelne Binärdatei, mit der du den Kubernetes-Cluster und/oder das KubeSphere-Administrations-Dashboard installieren kannst. Er unterstützt auch Cloud-native Add-ons, Multi-Knoten und HA (High Availability).

Gib den folgenden Befehl ein, um die Binärdatei von KubeKey in dein aktuelles Arbeitsverzeichnis herunterzuladen. Wenn der Vorgang abgeschlossen ist, solltest du die Datei „kk“ in deinem Verzeichnis sehen.

curl -sfL https://get-kk.kubesphere.io | VERSION=v3.0.2 sh -

Führe nun den folgenden Befehl aus, um die Datei„kk“ ausführbar zu machen.

chmod +x kk

Führe dann die Binärdatei‚kk‚ aus, um die aktuelle Version und die verfügbaren Parameter der Liste auf dem KubeKey zu überprüfen.

./kk version
./kk help

Unten siehst du eine ähnliche Ausgabe, die auf deinem Terminalbildschirm ausgedruckt wird.

Nachdem KubeKey heruntergeladen wurde, beginnst du mit der Konfiguration der Kubernetes- und Kubesphere-Bereitstellung über KubeKey.

Kubernetes- und Kubesphere-Deployment-Konfiguration erstellen

Der KubeKey kann für die reine Kubernetes-Bereitstellung oder mit der KubeSphere verwendet werden. Außerdem unterstützt er sowohl Einzelkubernetes- als auch Multiknoten-Deployments.

Für den Einsatz von Kubernetes und Kubesphere mit mehreren Knoten musst du ein YAML-Skript erstellen, das die Konfiguration des Servers festlegt.

Führe den folgenden„kk“ -Befehl aus, um eine neue YAML-Konfiguration zu erstellen. In diesem Beispiel erstellst du ein neues YAML-Skript„deployment-kubesphre.yml“ und gibst die Kubernetes-Version v1.24.2 und Kubesphere v3.3.1 an.

./kk create config -f deployment-kubesphre.yml --with-kubernetes v1.24.2 --with-kubesphere v3.3.1

Du solltest eine Ausgabe wie„Generate KubeKey config file successfully“ sehen.

Öffne nun die YAML-Datei„deployment-kubesphre.yml“ mit dem folgenden nano-Editor-Befehl.

nano deployment-kubesphre.yml

Ändere den Clusternamen im Parameter„metadata: testdeployment“ und ändere die IP-Adresse des Detail-Hosts, den Benutzer und den privaten Schlüssel für das Logging auf den Zielservern. Schließlich gibst du in der„roleGroup“ an, welcher Host als Control Plane und Worker Nodes verwendet werden soll.

apiVersion: kubekey.kubesphere.io/v1alpha2
kind: Cluster
metadata:
  name: testdeployment
spec:
  hosts:
  - {name: master, address: 192.168.5.35, internalAddress: 192.168.5.35, user: ubuntu, privateKeyPath: "~/.ssh/id_ed25519"}
  - {name: node1, address: 192.168.5.121, internalAddress: 192.168.5.121, user: ubuntu, privateKeyPath: "~/.ssh/id_ed25519"}
  - {name: node2, address: 192.168.5.122, internalAddress: 192.168.5.122, user: ubuntu, privateKeyPath: "~/.ssh/id_ed25519"}
  roleGroups:
    etcd:
    - master
    control-plane:
    - master
    worker:
    - node1
    - node2

Speichere die Datei und beende den Editor, wenn du fertig bist.

In diesem Beispiel wirst du einen neuen Kubernetes-Cluster mit dem Namen „testdeployment“ mit drei verschiedenen Ubuntu-Servern erstellen.

• master als etcd und Control Plane.
• node1 und node2 werden als Worker Nodes verwendet.

Um alle Anforderungen auf den Zielservern zu installieren, benutzt du SSH und meldest dich mit dem privaten Schlüssel„~/.ssh/id_ed25519“ als Benutzer„ubuntu“ an. Dieser Benutzer ist in visudo als passwortlos konfiguriert.

Nachdem du die YAML-Datei erstellt und konfiguriert und das Kubernetes- und Kubesphre-Deployment erstellt hast, kannst du mit den folgenden Schritten fortfahren, um das Deployment zu starten.

Bereitstellung von Kubernetes und Kubesphere

In diesem Abschnitt wirst du sowohl Kubernetes als auch Kubesphere mit Multi-Knoten-Architektur über KubeKey und das YAML-Skript„deployment-kubesphre.yml“ bereitstellen.

Führe die Kubekey-Binärdatei„kk“ unten aus, um das Kubernetes- und Kubesphere-Deployment mit der YAML-Datei„deployment-kubesphre.yml“ zu starten.

./kk create cluster -f deployment-kubesphre.yml

Zunächst prüft KubeKey die Voraussetzungen für die Kubernetes-Installation. Wenn die Installation erfolgreich war, wirst du aufgefordert, sie zu bestätigen. Gib Ja ein und drücke ENTER, um fortzufahren.

Es wird etwa 5-10 Minuten dauern, bis die Installation abgeschlossen ist. Wenn sie abgeschlossen ist, solltest du eine ähnliche Ausgabe wie diese auf deinem Terminal sehen. Außerdem erhältst du den Standard-Admin-Benutzer und das Passwort, mit denen du dich bei Kubesphere anmelden kannst.

Öffne nun deinen Webbrowser und rufe die IP-Adresse des „Master“-Servers auf, gefolgt von Port „30880“ (d.h.: http://192.168.5.35:30880/). Du solltest die Anmeldeseite von Kubepshre sehen.

Gib den Benutzer„admin“ und das Standardpasswort„P@88w0rd“ ein und klicke auf „Anmelden“.

Nach dem Einloggen solltest du aufgefordert werden, das Standardpasswort für den Kubepshre-Benutzer„admin“ zu ändern. Gib dein neues Passwort ein und klicke auf Absenden.

Wenn du fertig bist, solltest du das Dashboard der Kubesphere-Administration sehen. Auf der Dashboard-Seite sollte die aktuelle Version von Kubesphere v3.3.1 angezeigt werden und der verfügbare Kubernetes-Cluster ist 1.

Als Nächstes klickst du oben links auf das Menü Plattform und wählst dann Cluster Management.

Unten siehst du die Details des Kubernetes-Clusters, den du mit mehreren Ubuntu-Servern, dem Server„master„, node1 und node2 installiert hast.

Klicke nun auf das Menü Nodes, um detaillierte Informationen über die verfügbaren Nodes im Kubernetes-Cluster zu erhalten. Unten siehst du, dass es drei verschiedene Nodes im Kubernetes-Cluster gibt. Der„Master„-Server wird sowohl als Control Plane als auch als Worker Node verwendet.

Klicke nun auf die Systemkomponenten, um die Details der installierten Komponenten in deinem Kubernetes- und Kubesphere-Einsatz zu sehen. Du kannst drei verschiedene Kategorien von Komponenten sehen: Kubesphere, Kubernetes und Monitoring.

Als Nächstes kehrst du zur Terminalsitzung des „Master“-Servers zurück und führst den folgenden„kubectl„-Befehl aus, um die Liste der verfügbaren Knoten in deinem Kubernetes-Cluster zu erhalten.

kubectl get nodes

Du solltest eine ähnliche Ausgabe erhalten wie diese – Es sind drei Knoten im Kubernetes-Cluster verfügbar: der Master-Knoten, der als Control Plane verwendet wird, und die Knoten 1 und 2, die als Worker-Knoten dienen.

Gib den folgenden Befehl ein, um detaillierte Informationen über jeden Knoten des Kubernetes-Clusters zu erhalten.

kubectl describe node

Unten siehst du die Details der Kubernetes-Kontrollebene auf dem„Master„-Server.

Unten siehst du die Details des Worker Nodes auf dem Server node1.

Unten siehst du die Details des Worker Nodes auf dem Server node2.

Gib schließlich den folgenden Befehl ein, um die Liste der Pods zu erhalten, die in deinem Kubernetes-Cluster laufen.

kubectl get pods --all-namespaces

In der folgenden Ausgabe siehst du die Namespaces„kube-system“, „kubesphere-system“, „kubesphere-control-system“ und„kubesphere-monitoring-system„, die in deinem Kubernetes-Cluster verfügbar sind und in denen alle Pods laufen.

Jetzt hast du den Kubernetes-Cluster und Kubesphere mit mehreren Ubuntu-Serverknoten eingerichtet. Außerdem hast du auf das Administrations-Dashboard von Kubesphere zugegriffen und das Standardpasswort für den Administrator geändert.

Damit kannst du jetzt deine Anwendung in Kubernetes und Kubesphere bereitstellen. Im nächsten Schritt stellst du den einfachen Nginx-Webserver in Kubernetes bereit, um sicherzustellen, dass deine Installation von Kubernetes und Kubesphere erfolgreich ist.

Pods für Kubernetes und Kubesphere bereitstellen

In diesem Beispiel wirst du Nginx-Pods für den Kubernetes-Cluster und Kubesphere bereitstellen.

Führe den folgenden Befehl aus, um eine neue Bereitstellung 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„32241“ auf den Kubernetes-Hosts freigibt. Der Dienst NodePort gibt auf den Kubernetes-Hosts (Worker Nodes) immer den Port im Bereich xxx-xxxx an.

kubectl get svc

Führe den folgenden curl-Befehl aus, um auf deinen Nginx-Einsatz zuzugreifen.

curl 10.233.14.102
curl node1:32241
curl node2:32241

Unten siehst du die Ausgabe der index.html-Seite des Nginx-Pods, die auf dem„Master„-Server angezeigt wird.

Unten siehst du die Ausgabe des index.html-Quellcodes von„node1„.

Und unten ist der index.html-Code von„node2„.

Nun zurück zum Kubesphere Administrations-Dashboard. Klicke auf die Anwendungs-Workloads und dann auf Workloads. Du wirst sehen, dass das Deployment„nginx“ verfügbar ist und zwei Pods laufen.

Klicke auf den Einsatz„nginx„, um detaillierte Informationen über deinen Einsatz zu erhalten. Du solltest sehen, dass der„nginx„-Einsatz zwei Replikate enthält und dass die Replikate dieser beiden Pods laufen.

Als Nächstes klickst du auf das Menü Dienste, um eine Liste der in deinem Kubernetes-Cluster verfügbaren Dienste zu erhalten. Du solltest sehen, dass die Dienste„nginx“ und„Kubernetes“ in deinem Cluster verfügbar sind.

Klicke auf den Dienst„nginx„, um detaillierte Informationen über den Dienst zu erhalten. Unten siehst du eine ähnliche Seite, die auf deinem Kubesphere Dashboard angezeigt wird.

Damit hast du die Einrichtung von Nginx-Pods im Kubernetes-Cluster abgeschlossen und die Details der Einrichtung im Kubesphere-Administrations-Dashboard überprüft.

Fazit

In diesem Tutorial hast du nun den Kubernetes-Cluster und Kubesphre auf mehreren Ubuntu 22.04-Servern eingerichtet. Du hast Kubernetes mit dem von Kubesphere entwickelten Automatisierungstool „KubeKey“ implementiert. Du hast auch die grundlegende Konfiguration von Ubuntu-Servern für die Kubernetes-Bereitstellung gelernt.

Außerdem hast du Kubesphere als Webadministrations-Dashboard für Kubernetes erfolgreich installiert und konfiguriert. Du hast die grundlegenden Funktionen von Kubesphere für die Verwaltung von Kubernetes-Clustern, Deployments, Pods und Diensten kennengelernt.

Um mehr über Kubesphere zu erfahren, besuche die offiziellen Dokumentationen von Kubesphere. Was Kubernetes betrifft, besuche die offizielle Dokumentation von Kubernetes.