Autor: Lao Z, ein Betriebs- und Wartungsarchitekt von China Telecom Digital Intelligence Technology Co., Ltd. Shandong Branch, ein Cloud-Native-Enthusiast, der sich derzeit auf Cloud-Native-Betrieb und -Wartung sowie den Technologie-Stack im Cloud-Native-Bereich konzentriert umfasst Kubernetes, KubeSphere, DevOps, OpenStack, Ansible usw.
Vorwort
Karte
Wissenspunkte
- Bewertung: Einstiegsniveau
- KubeKey-Installation und Bereitstellung von KubeSphere und Kubernetes
- Grundkonfiguration des Ubuntu-Betriebssystems
- Erstellung gängiger Kubernetes-Workloads
Demo-Server-Konfiguration
| CPU-Name | IP | Zentralprozessor | Speicher | Systemfestplatte | Datenträger | verwenden |
|---|---|---|---|---|---|---|
| ks-master-0 | 192.168.9.91 | 4 | 16 | 40 | 200 | KubeSphere/k8s-master/k8s-worker |
| ks-master-1 | 192.168.9.92 | 4 | 16 | 40 | 200 | KubeSphere/k8s-master/k8s-worker |
| ks-master-2 | 192.168.9.93 | 4 | 16 | 40 | 200 | KubeSphere/k8s-master/k8s-worker |
| gesamt | 3 | 12 | 48 | 120 | 600 |
Die Demo-Umgebung umfasst Informationen zur Softwareversion
- Betriebssystem: Ubuntu 22.04.2 LTS
- KubeSphere: 3.3.2
- Kubernetes: v1.25.5
- KubeKey: v3.0.7
Einführung
In diesem Artikel wird beschrieben, wie Sie einen KubeSphere- und Kubernetes-Cluster auf einem Ubuntu 22.04 LTS-Server bereitstellen. Wir werden das von KubeSphere entwickelte KubeKey-Tool verwenden, um die automatisierte Bereitstellung zu implementieren, und den Hochverfügbarkeitsmodus auf drei Servern implementieren, um die Bereitstellung von Kubernetes-Clustern und KubeSphere zu minimieren. Wir stellen detaillierte Bereitstellungsanweisungen zur Verfügung, damit die Leser den Bereitstellungsprozess problemlos durchführen können.
Grundkonfiguration des Betriebssystems
Bitte beachten Sie, dass die folgenden Vorgänge auf allen Ubuntu-Servern durchgeführt werden müssen, sofern nicht anders angegeben. Dieser Artikel dient nur einem der Server als Demonstration und geht davon aus, dass die übrigen Server auf die gleiche Weise konfiguriert und eingerichtet sind.
Benutzer erstellen
Vor der Installation von KubeSphere und Kubernetes müssen Sie einen gemeinsamen Benutzer erstellen. Dies kann der ursprüngliche Benutzer sein, den Ubuntu standardmäßig bei der Installation des Ubuntu-Systems erstellt hat , oder ein neu erstellter Benutzer. In diesem Artikel verwenden wir den neu erstellten Benutzer kube als Beispiel.
- Erstellen Sie einen Benutzer und legen Sie ein Passwort fest
Erstellen Sie einen neuen Benutzer mit dem Namen kube und legen Sie ein Passwort für diesen Benutzer fest , indem Sie den folgenden Befehl ausführen . Wenn Sie zur Eingabe eines Passworts aufgefordert werden, geben Sie das gewünschte Passwort ein und bestätigen Sie es.
sudo useradd -m -s /bin/bash kube
sudo passwd kube
- Konfigurieren Sie Benutzer so, dass sie Befehle ohne Passwörter ausführen
Um KubeSphere und Kubernetes zu installieren und bereitzustellen, muss der Kube- Benutzer so konfiguriert werden, dass er mit sudo zum Root-Benutzer wechselt, um Systembefehle ohne Kennwort auszuführen.
Um dem kube- Benutzer die Verwendung des sudo-Befehls ohne Passwort zu ermöglichen, führen Sie den folgenden Befehl aus.
cat <<EOF | sudo tee /etc/sudoers.d/kube
Defaults:kube !fqdn
Defaults:kube !requiretty
kube ALL=(ALL) NOPASSWD: ALL
EOF
Hostnamen konfigurieren
sudo hostnamectl hostname ks-master-0
Konfigurieren Sie die Hosts-Datei
Bearbeiten Sie die Datei /etc/hosts und fügen Sie der Datei die geplante Server-IP und den Hostnamen hinzu.
192.168.9.91 ks-master-0
192.168.9.92 ks-master-1
192.168.9.93 ks-master-2
Konfigurieren Sie die schlüsselbasierte SSH-Authentifizierung
KubeKey unterstützt die Verwendung von Passwörtern und Schlüsseln als Verbindungsauthentifizierungsmethoden für Remote-Server bei der automatischen Bereitstellung von KubeSphere- und Kubernetes-Diensten. In diesem Artikel wird gezeigt, wie Sie Passwörter und Schlüssel gleichzeitig konfigurieren. Daher ist es notwendig, die passwortfreie SSH-Authentifizierung für den Bereitstellungsbenutzer kube zu konfigurieren.
Dieser Abschnitt ist ein optionales Konfigurationselement. Wenn Sie ein reines Passwort als Authentifizierungsmethode für die Server-Remoteverbindung verwenden, können Sie diesen Abschnitt ignorieren.
In diesem Artikel wird der Master-0-Knoten als Bereitstellungsknoten verwendet. Die folgenden Vorgänge müssen auf dem Master-0- Knoten ausgeführt werden.
Melden Sie sich als kube-Benutzer beim System an und verwenden Sie dann den Befehl ssh-keygen , um ein neues SSH-Schlüsselpaar zu generieren. Nach Abschluss des Befehls werden der öffentliche SSH-Schlüssel und der private Schlüssel im Verzeichnis /home/kube/ gespeichert. ssh- Verzeichnis.
su - kube
ssh-keygen -t ed25519
Der Effekt der Befehlsausführung ist wie folgt:
ubuntu@ks-master-0:~$ su - kube
Password:
kube@ks-master-0:~$ ssh-keygen -t ed25519
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/kube/.ssh/id_ed25519):
Created directory '/home/kube/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/kube/.ssh/id_ed25519
Your public key has been saved in /home/kube/.ssh/id_ed25519.pub
The key fingerprint is:
SHA256:tQzVX/3bF87KzKjYnZcm6M3wdMRRlKyixFtCTQOcBks kube@ks-master-0
The key's randomart image is:
+--[ED25519 256]--+
| Eo.*+ ooo|
| . .* .o .oo|
| .= . o...|
| B +..o..|
| S B .oo +|
| o . +o|
| ...=.o .|
| o.BooO |
| ..+.*+ |
+----[SHA256]-----+
Geben Sie als Nächstes den folgenden Befehl ein, um den öffentlichen SSH-Schlüssel vom Master-0- Knoten an andere Knoten zu senden. Geben Sie „Ja“ ein , wenn der Befehl ausgeführt wird , um den SSH-Fingerabdruck des Servers zu akzeptieren, und geben Sie dann das Kennwort des Kube- Benutzers ein , wenn Sie dazu aufgefordert werden .
ssh-copy-id kube@ks-master-0
Das Folgende ist die korrekte Ausgabe, wenn der Schlüssel kopiert wird:
kube@ks-master-0:~$ ssh-copy-id kube@ks-master-0
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/kube/.ssh/id_ed25519.pub"
The authenticity of host 'ks-master-0 (192.168.9.91)' can't be established.
ED25519 key fingerprint is SHA256:XMc3FWjoTJY6TFH7BK3S6bRmLt+ZxoPvdUh9Dz3ENgk.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
kube@ks-master-0's password:
Number of key(s) added: 1
Now try logging into the machine, with: "ssh 'kube@ks-master-0'"
and check to make sure that only the key(s) you wanted were added.
Nachdem Sie den öffentlichen SSH-Schlüssel hinzugefügt und hochgeladen haben, können Sie nun den folgenden Befehl ausführen, um zu überprüfen, ob Sie über den kube-Benutzer eine Verbindung zu allen Servern ohne Passwortüberprüfung herstellen können.
kube@ks-master-0:~$ ssh kube@ks-master-1
# 登陆输出结果 略
Installieren Sie Systemabhängigkeiten
Melden Sie sich auf allen Knoten als kube- Benutzer beim System an (nicht erforderlich, andere Systembenutzer sind ebenfalls akzeptabel) und führen Sie den folgenden Befehl aus, um die grundlegenden Systemabhängigkeitspakete für Kubernetes zu installieren.
sudo apt-get update
sudo apt-get install curl socat conntrack ebtables ipset ipvsadm
Konfigurieren Sie die Zeitzone des Servers
Konfigurieren Sie die Serverzeitzone als Asien/Shanghai :
sudo timedatectl set-timezone Asia/Shanghai
Installieren Sie chrony und konfigurieren Sie die Zeitsynchronisierung
Installieren Sie chrony als Zeitsynchronisierungssoftware:
sudo apt-get install chrony
Ändern Sie die Konfigurationsdatei /etc/chrony/chrony.conf und ändern Sie die NTP-Serverkonfiguration:
sudo vi /etc/chrony/chrony.conf
# 删除所有的 pool 配置
pool ntp.ubuntu.com iburst maxsources 4
pool 0.ubuntu.pool.ntp.org iburst maxsources 1
pool 1.ubuntu.pool.ntp.org iburst maxsources 1
pool 2.ubuntu.pool.ntp.org iburst maxsources 2
# 增加国内的 ntp 服务器，或是指定其他常用的时间服务器
server ntp.api.bz iburst
Starten Sie den Chrony-Dienst neu:
sudo systemctl restart chrony
Überprüfen Sie den Chrony-Synchronisierungsstatus:
# 执行查看命令
sudo chronyc sourcestats -v
# 正常的输出结果如下
kube@ks-master-0:~/kubekey$ sudo chronyc sourcestats -v
.- Number of sample points in measurement set.
/ .- Number of residual runs with same sign.
| / .- Length of measurement set (time).
| | / .- Est. clock freq error (ppm).
| | | / .- Est. error in freq.
| | | | / .- Est. offset.
| | | | | | On the -.
| | | | | | samples. \
| | | | | | |
Name/IP Address NP NR Span Frequency Freq Skew Offset Std Dev
==============================================================================
185.53.177.52 0 0 0 +0.000 2000.000 +0ns 4000ms
Installieren und bereitstellen Sie KubeSphere und Kubernetes
Laden Sie KubeKey herunter
In diesem Artikel wird der Master-0-Knoten als Bereitstellungsknoten verwendet und die Binärdatei der neuesten Version (3.0.7) von KubeKey (im Folgenden als kk bezeichnet) wird auf den Server heruntergeladen. Die spezifische KubeKey-Versionsnummer kann auf der KubeKey-Release-Seite eingesehen werden .
- Laden Sie die neueste Version von KubeKey herunter
cd ~
mkdir kubekey
cd kubekey/
# 选择中文区下载(访问github受限时使用)
export KKZONE=cn
curl -sfL https://get-kk.kubesphere.io | sh -
# 也可以使用下面的命令指定具体版本
curl -sfL https://get-kk.kubesphere.io | VERSION=v3.0.7 sh -
# 正确的执行效果如下
kube@ks-master-0:~$ cd ~
kube@ks-master-0:~$ mkdir kubekey
kube@ks-master-0:~$ cd kubekey/
kube@ks-master-0:~/kubekey$ export KKZONE=cn
kube@ks-master-0:~/kubekey$ curl -sfL https://get-kk.kubesphere.io | sh -
Downloading kubekey v3.0.7 from https://kubernetes.pek3b.qingstor.com/kubekey/releases/download/v3.0.7/kubekey-v3.0.7-linux-amd64.tar.gz ...
Kubekey v3.0.7 Download Complete!
kube@ks-master-0:~/kubekey$ ll
total 111996
drwxrwxr-x 2 kube kube 4096 May 17 07:19 ./
drwxr-x--- 5 kube kube 4096 May 17 07:17 ../
-rwxr-xr-x 1 kube kube 78901793 Jan 18 01:59 kk*
-rw-rw-r-- 1 kube kube 35769576 May 17 07:19 kubekey-v3.0.7-linux-amd64.tar.gz
- Sehen Sie sich die Liste der von KubeKey unterstützten Kubernetes-Versionen an
./kk version --show-supported-k8s
# 输出如下
kube@ks-master-0:~/kubekey$ ./kk version --show-supported-k8s
v1.19.0
v1.19.8
v1.19.9
v1.19.15
v1.20.4
v1.20.6
v1.20.10
v1.21.0
v1.21.1
v1.21.2
v1.21.3
v1.21.4
v1.21.5
v1.21.6
v1.21.7
v1.21.8
v1.21.9
v1.21.10
v1.21.11
v1.21.12
v1.21.13
v1.21.14
v1.22.0
v1.22.1
v1.22.2
v1.22.3
v1.22.4
v1.22.5
v1.22.6
v1.22.7
v1.22.8
v1.22.9
v1.22.10
v1.22.11
v1.22.12
v1.22.13
v1.22.14
v1.22.15
v1.22.16
v1.22.17
v1.23.0
v1.23.1
v1.23.2
v1.23.3
v1.23.4
v1.23.5
v1.23.6
v1.23.7
v1.23.8
v1.23.9
v1.23.10
v1.23.11
v1.23.12
v1.23.13
v1.23.14
v1.23.15
v1.24.0
v1.24.1
v1.24.2
v1.24.3
v1.24.4
v1.24.5
v1.24.6
v1.24.7
v1.24.8
v1.24.9
v1.25.0
v1.25.1
v1.25.2
v1.25.3
v1.25.4
v1.25.5
v1.26.0
Erstellen Sie Kubernetes- und KubeSphere-Bereitstellungsprofile
Erstellen Sie eine Cluster-Konfigurationsdatei. Wählen Sie in diesem Beispiel KubeSphere v3.3.2 und Kubernetes v1.25.5 aus. Geben Sie gleichzeitig den Namen der Konfigurationsdatei als kubesphere-v3.3.2.yaml an . Wenn nicht angegeben, lautet der Standarddateiname config -sample.yaml .
./kk create config -f kubesphere-v3.3.2.yaml --with-kubernetes v1.25.5 --with-kubesphere v3.3.2
Nachdem der Befehl erfolgreich ausgeführt wurde, wird im aktuellen Verzeichnis eine Konfigurationsdatei mit dem Namen kubesphere-v3.3.2.yaml generiert.
kube@ks-master-0:~/kubekey$ ./kk create config -f kubesphere-v3.3.2.yaml --with-kubernetes v1.25.5 --with-kubesphere v3.3.2
Generate KubeKey config file successfully
kube@ks-master-0:~/kubekey$ ls
kk kubekey-v3.0.7-linux-amd64.tar.gz kubesphere-v3.3.2.yaml
In diesem Beispiel werden drei Knoten als Control-Plane-Knoten verwendet und als Worker-Knoten gemultiplext.
Bearbeiten Sie die Konfigurationsdatei kubesphere-v3.3.2.yaml und ändern Sie Informationen wie Hosts und Rollengruppen. Die Änderungsanweisungen lauten wie folgt.
- hosts gibt die IP, den SSH-Benutzer, das SSH-Passwort und den SSH-H-Schlüssel des Knotens an. Das Beispiel zeigt die Konfigurationsmethode, bei der Passwort und Schlüssel gleichzeitig verwendet werden
- RoleGroups gibt ks-master-0, ks-master-1, ks-master-2 als etcd, Kontrollebene, Arbeitsknoten an
- internalLoadbalancer aktiviert den integrierten HAProxy Load Balancer
Das modifizierte Beispiel lautet wie folgt:
apiVersion: kubekey.kubesphere.io/v1alpha2
kind: Cluster
metadata:
name: sample
spec:
hosts:
- {name: ks-master-0, address: 192.168.9.91, internalAddress: 192.168.9.91, user: kube, password: "P@88w0rd"}
- {name: ks-master-1, address: 192.168.9.92, internalAddress: 192.168.9.92, user: kube, privateKeyPath: "~/.ssh/id_ed25519"}
- {name: ks-master-2, address: 192.168.9.93, internalAddress: 192.168.9.93, user: kube, privateKeyPath: "~/.ssh/id_ed25519"}
roleGroups:
etcd:
- ks-master-0
- ks-master-1
- ks-master-2
control-plane:
- ks-master-0
- ks-master-1
- ks-master-2
worker:
- ks-master-0
- ks-master-1
- ks-master-2
controlPlaneEndpoint:
## Internal loadbalancer for apiservers
internalLoadbalancer: haproxy
domain: lb.kubesphere.local
address: ""
port: 6443
kubernetes:
version: v1.25.5
clusterName: cluster.local
autoRenewCerts: true
containerManager: containerd
etcd:
type: kubekey
network:
plugin: calico
kubePodsCIDR: 10.233.64.0/18
kubeServiceCIDR: 10.233.0.0/18
## multus support. https://github.com/k8snetworkplumbingwg/multus-cni
multusCNI:
enabled: false
registry:
privateRegistry: ""
namespaceOverride: ""
registryMirrors: []
insecureRegistries: []
addons: []
Stellen Sie KubeSphere und Kubernetes bereit
Als Nächstes führen wir den folgenden Befehl aus, um KubeSphere und Kubernetes mithilfe der oben generierten Konfigurationsdatei bereitzustellen.
./kk create cluster -f kubesphere-v3.3.2.yaml
Nachdem der obige Befehl ausgeführt wurde, prüft kk zunächst die Abhängigkeiten und andere detaillierte Anforderungen für die Bereitstellung von Kubernetes. Nach bestandener Prüfung werden Sie aufgefordert, die Installation zu bestätigen. Geben Sie „Ja“ ein und drücken Sie die EINGABETASTE, um mit der Bereitstellung fortzufahren.
kube@ks-master-0:~/kubekey$ ./kk create cluster -f kubesphere-v3.3.2.yaml
_ __ _ _ __
| | / / | | | | / /
| |/ / _ _| |__ ___| |/ / ___ _ _
| \| | | | '_ \ / _ \ \ / _ \ | | |
| |\ \ |_| | |_) | __/ |\ \ __/ |_| |
\_| \_/\__,_|_.__/ \___\_| \_/\___|\__, |
__/ |
|___/
16:24:04 CST [GreetingsModule] Greetings
16:24:05 CST message: [ks-master-2]
Greetings, KubeKey!
16:24:06 CST message: [ks-master-0]
Greetings, KubeKey!
16:24:08 CST message: [ks-master-1]
Greetings, KubeKey!
16:24:08 CST success: [ks-master-2]
16:24:08 CST success: [ks-master-0]
16:24:08 CST success: [ks-master-1]
16:24:08 CST [NodePreCheckModule] A pre-check on nodes
16:24:08 CST success: [ks-master-0]
16:24:08 CST success: [ks-master-2]
16:24:08 CST success: [ks-master-1]
16:24:08 CST [ConfirmModule] Display confirmation form
+-------------+------+------+---------+----------+-------+-------+---------+-----------+--------+--------+------------+------------+-------------+------------------+--------------+
| name | sudo | curl | openssl | ebtables | socat | ipset | ipvsadm | conntrack | chrony | docker | containerd | nfs client | ceph client | glusterfs client | time |
+-------------+------+------+---------+----------+-------+-------+---------+-----------+--------+--------+------------+------------+-------------+------------------+--------------+
| ks-master-0 | y | y | y | y | y | y | y | y | y | | | | | | CST 16:24:08 |
| ks-master-1 | y | y | y | y | y | y | y | y | y | | | | | | CST 16:24:08 |
| ks-master-2 | y | y | y | y | y | y | y | y | y | | | | | | CST 16:24:08 |
+-------------+------+------+---------+----------+-------+-------+---------+-----------+--------+--------+------------+------------+-------------+------------------+--------------+
This is a simple check of your environment.
Before installation, ensure that your machines meet all requirements specified at
https://github.com/kubesphere/kubekey#requirements-and-recommendations
Continue this installation? [yes/no]:
Die Bereitstellung dauert je nach Netzwerkgeschwindigkeit und Maschinenkonfiguration etwa 10 bis 30 Minuten.
Nach Abschluss der Bereitstellung sollte auf dem Terminal eine Ausgabe ähnlich der folgenden angezeigt werden. Während Sie darauf hingewiesen werden, dass die Bereitstellung abgeschlossen ist, werden in der Ausgabe auch der Standardadministratorbenutzer und das Standardkennwort angezeigt, damit sich der Benutzer bei KubeSphere anmelden kann.
clusterconfiguration.installer.kubesphere.io/ks-installer created
16:36:44 CST skipped: [ks-master-2]
16:36:44 CST skipped: [ks-master-1]
16:36:44 CST success: [ks-master-0]
#####################################################
### Welcome to KubeSphere! ###
#####################################################
Console: http://192.168.9.91:30880
Account: admin
Password: P@88w0rd
NOTES：
1. After you log into the console, please check the
monitoring status of service components in
"Cluster Management". If any service is not
ready, please wait patiently until all components
are up and running.
2. Please change the default password after login.
#####################################################
https://kubesphere.io 2023-05-17 16:48:38
#####################################################
16:48:43 CST skipped: [ks-master-2]
16:48:43 CST skipped: [ks-master-1]
16:48:43 CST success: [ks-master-0]
16:48:43 CST Pipeline[CreateClusterPipeline] execute successfully
Installation is complete.
Please check the result using the command:
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l 'app in (ks-install, ks-installer)' -o jsonpath='{.items[0].metadata.name}') -f
Bereitstellungsüberprüfung
- Überprüfen Sie die KubeSphere-Verwaltungskonsole
Wir öffnen den Browser, um auf die IP-Adresse und den Port „30880“ des Master-0-Knotens zuzugreifen, und sehen die Anmeldeseite der KubeSphere-Verwaltungskonsole.
Geben Sie den Standardbenutzer admin und das Standardkennwort P@88w0rd ein und klicken Sie auf „Anmelden“.
Nach der Anmeldung werden Sie aufgefordert, das Standardkennwort des KubeSphere-Standardbenutzers „admin“ zu ändern, das neue Kennwort einzugeben und auf „Senden“ zu klicken.
Nachdem die Übermittlung abgeschlossen ist, springt das System zur KubeSphere-Administrator-Benutzer-Workbench-Seite, auf der angezeigt wird, dass die aktuelle KubeSphere-Version v3.3.2 ist und die Anzahl der verfügbaren Kubernetes-Cluster 1 beträgt.
Klicken Sie anschließend oben links auf das Menü „Plattformverwaltung“ und wählen Sie „Clusterverwaltung“.
Rufen Sie die Cluster-Verwaltungsschnittstelle auf. Auf dieser Seite können Sie die grundlegenden Informationen des Clusters anzeigen, einschließlich Cluster-Ressourcennutzung, Kubernetes-Status, Knotenressourcennutzung Top, Systemkomponenten, Toolbox usw.
Klicken Sie links auf das Menü „Knoten“ und dann auf „Clusterknoten“, um die Details der verfügbaren Knoten im Kubernetes-Cluster anzuzeigen.
Klicken Sie links auf das Menü „Systemkomponenten“, um detaillierte Informationen zu den installierten Komponenten anzuzeigen. Die aktuell vom Cluster verwendete Minimalinstallation umfasst nur drei Kategorien von Komponenten: KubeSphere, Kubernetes und Überwachung.
- Überprüfen Sie die Clusterinformationen über die Befehlszeile
Führen Sie den Befehl kubectl auf dem Master-0-Knoten aus, um eine Liste der verfügbaren Knoten im Kubernetes-Cluster abzurufen
kubectl get nodes
Wie Sie der Ausgabe entnehmen können, verfügt der aktuelle Kubernetes-Cluster über drei verfügbare Knoten: die interne IP des Knotens, die Rolle des Knotens, die Versionsnummer von Kubernetes des Knotens, die Laufzeit- und Versionsnummer des Containers sowie den Betrieb Systemtyp und die Kernel-Version.
kube@ks-master-0:~/kubekey$ kubectl get nodes -o wide
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
ks-master-0 Ready control-plane,worker 36m v1.25.5 192.168.9.91 <none> Ubuntu 22.04.2 LTS 5.15.0-70-generic containerd://1.6.4
ks-master-1 Ready control-plane,worker 35m v1.25.5 192.168.9.92 <none> Ubuntu 22.04.2 LTS 5.15.0-70-generic containerd://1.6.4
ks-master-2 Ready control-plane,worker 35m v1.25.5 192.168.9.93 <none> Ubuntu 22.04.2 LTS 5.15.0-70-generic containerd://1.6.4
Geben Sie den folgenden Befehl ein, um eine Liste der Pods abzurufen, die im Kubernetes-Cluster ausgeführt werden:
kubectl get pods --all-namespaces
Wie Sie in der Ausgabe sehen können, sind im Kubernetes-Cluster mehrere Namespaces kube-system, kubesphere-control-system, kubesphere-monitoring-system und kubesphere-system verfügbar und alle Pods werden ausgeführt.
kube@ks-master-0:~/kubekey$ kubectl get pods --all-namespaces
NAMESPACE NAME READY STATUS RESTARTS AGE
kube-system calico-kube-controllers-75c594996d-mfl2c 1/1 Running 0 37m
kube-system calico-node-2xhqh 1/1 Running 0 37m
kube-system calico-node-6vcl9 1/1 Running 0 37m
kube-system calico-node-l9p9s 1/1 Running 0 37m
kube-system coredns-67ddbf998c-t2z87 1/1 Running 0 38m
kube-system coredns-67ddbf998c-xff4b 1/1 Running 0 38m
kube-system kube-apiserver-ks-master-0 1/1 Running 0 38m
kube-system kube-apiserver-ks-master-1 1/1 Running 0 37m
kube-system kube-apiserver-ks-master-2 1/1 Running 0 37m
kube-system kube-controller-manager-ks-master-0 1/1 Running 0 38m
kube-system kube-controller-manager-ks-master-1 1/1 Running 0 37m
kube-system kube-controller-manager-ks-master-2 1/1 Running 0 37m
kube-system kube-proxy-czmpt 1/1 Running 0 37m
kube-system kube-proxy-mddtt 1/1 Running 0 37m
kube-system kube-proxy-vjdzl 1/1 Running 0 37m
kube-system kube-scheduler-ks-master-0 1/1 Running 0 38m
kube-system kube-scheduler-ks-master-1 1/1 Running 0 37m
kube-system kube-scheduler-ks-master-2 1/1 Running 0 37m
kube-system nodelocaldns-5zpnj 1/1 Running 0 37m
kube-system nodelocaldns-8849d 1/1 Running 0 38m
kube-system nodelocaldns-v97cd 1/1 Running 0 37m
kube-system openebs-localpv-provisioner-57d95c6875-lwvqt 1/1 Running 0 37m
kube-system snapshot-controller-0 1/1 Running 0 35m
kubesphere-controls-system default-http-backend-5d5c44d77f-kst9l 1/1 Running 0 31m
kubesphere-controls-system kubectl-admin-788ff75cd7-4wqtc 1/1 Running 0 25m
kubesphere-monitoring-system kube-state-metrics-6cc9478499-9fr7h 3/3 Running 0 28m
kubesphere-monitoring-system node-exporter-dzqw5 2/2 Running 0 28m
kubesphere-monitoring-system node-exporter-f6wvj 2/2 Running 0 28m
kubesphere-monitoring-system node-exporter-kqtj8 2/2 Running 0 28m
kubesphere-monitoring-system prometheus-k8s-0 2/2 Running 0 28m
kubesphere-monitoring-system prometheus-k8s-1 2/2 Running 0 28m
kubesphere-monitoring-system prometheus-operator-6bd484db88-l6666 2/2 Running 0 28m
kubesphere-system ks-apiserver-6797fc669-dr9gs 1/1 Running 0 31m
kubesphere-system ks-console-6f9d57b699-whg9w 1/1 Running 0 31m
kubesphere-system ks-controller-manager-6656d4f57d-gfc5x 1/1 Running 0 31m
kubesphere-system ks-installer-55b8b4c4d9-9gvjh 1/1 Running 0 37m
Bisher haben wir einen minimalen Kubernetes-Cluster mit drei Ubuntu-Serverknoten und KubeSphere bereitgestellt. Wir haben den Status des Clusters auch über die KubeSphere-Verwaltungskonsole und die Befehlszeilenschnittstelle angezeigt.
Als Nächstes stellen wir einen einfachen Nginx-Webserver im Kubernetes-Cluster bereit, um zu testen und zu überprüfen, ob Kubernetes und KubeSphere normalerweise verfügbar sind.
Testressourcen bereitstellen
In diesem Beispiel werden Befehlszeilentools verwendet, um einen Nginx-Webserver auf einem Kubernetes-Cluster bereitzustellen, und die grafische Verwaltungskonsole von KubeSphere wird verwendet, um bereitgestellte Ressourceninformationen anzuzeigen.
Erstellen Sie eine Nginx-Bereitstellung
Führen Sie den folgenden Befehl aus, um eine Bereitstellung zu erstellen, die den Nginx-Webserver bereitstellt. In diesem Beispiel erstellen wir einen Pod mit zwei Replikaten basierend auf dem nginx:alpine-Image.
kubectl create deployment nginx --image=nginx:alpine --replicas=2
Erstellen Sie einen Nginx-Dienst
Erstellen Sie einen neuen Kubernetes-Dienst mit dem Dienstnamen nginx, dem Diensttyp Nodeport und dem externen Dienstport 80.
kubectl create service nodeport nginx --tcp=80:80
Überprüfen Sie die Nginx-Bereitstellung und Pods
Führen Sie den folgenden Befehl aus, um die erstellten Bereitstellungs- und Pod-Ressourcen anzuzeigen.
kubectl get deployment -o wide
kubectl get pods -o wide
Sehen Sie sich die Ergebnisse wie folgt an:
kube@ks-master-0:~$ kubectl get deployment -o wide
NAME READY UP-TO-DATE AVAILABLE AGE CONTAINERS IMAGES SELECTOR
nginx 2/2 2 2 72s nginx nginx:alpine app=nginx
kube@ks-master-0:~$ kubectl get pods -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
nginx-55f494c486-85zsc 1/1 Running 0 78s 10.233.103.5 ks-master-1 <none> <none>
nginx-55f494c486-hpzlr 1/1 Running 0 78s 10.233.102.7 ks-master-2 <none> <none>
Überprüfen Sie den Nginx-Dienst
Führen Sie den Befehl aus, um die Liste der verfügbaren Dienste anzuzeigen. In der Liste können wir sehen, dass der Nginx-Diensttyp Nodeport ist und Port 32710 auf dem Kubernetes-Host geöffnet ist.
kubectl get svc -o wide
Sehen Sie sich die Ergebnisse wie folgt an:
kube@ks-master-0:~$ kubectl get svc -o wide
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE SELECTOR
kubernetes ClusterIP 10.233.0.1 <none> 443/TCP 16h <none>
nginx NodePort 10.233.10.40 <none> 80:32710/TCP 6m21s app=nginx
Greifen Sie auf den Nginx-Dienst zu
Führen Sie den folgenden Befehl aus, um auf den bereitgestellten Nginx-Dienst zuzugreifen und zu überprüfen, ob der Dienst erfolgreich bereitgestellt wurde.
- Authentifizieren des direkten Zugriffs auf Pods
curl 10.233.103.5
# 访问结果如下
kube@ks-master-0:~$ curl 10.233.103.5
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>
- Überprüfen Sie den Zugriff auf den Dienst
curl 10.233.10.40
# 访问结果同上，略
- Überprüfen Sie den Zugriff auf Nodeport
curl 192.168.9.91:32710
# 访问结果同上，略
Ansicht in der Verwaltungskonsole
Als nächstes kehren wir zur KubeSphere-Verwaltungskonsole zurück und sehen uns die erstellten Ressourcen in der Verwaltungskonsole an.
Hinweis: Die Verwaltungskonsole von KubeSphere hat die Funktion, verschiedene Kubernetes-Ressourcen auf benutzerfreundliche und grafische Weise zu erstellen. Der Hauptgrund dafür ist, dass Screenshots zu mühsam sind. Daher wird in diesem Artikel die Befehlszeile verwendet, um einfach Testressourcen zu erstellen.
Ich möchte Ihnen nur die Grundfunktionen der KubeSphere-Verwaltungskonsole beim Anzeigen zeigen. Im tatsächlichen Gebrauch können Sie Kubernetes-Ressourcen grafisch erstellen und verwalten.
- Melden Sie sich bei der KubeSphere-Verwaltungskonsole an, klicken Sie auf „Plattformverwaltung“ und wählen Sie „Clusterverwaltung“.
- Klicken Sie auf der linken Seite der Clusterverwaltungsseite auf „Anwendungslast“ und dann auf „Arbeitslast“. Standardmäßig werden alle Workloads vom Typ „Bereitstellung“ angezeigt .
Wir verwenden das Administratorkonto, damit wir alle Workloads sehen können. Geben Sie „nginx“ in das Suchfeld ein und es werden nur Nginx-Bereitstellungs-Workloads angezeigt.
- Klicken Sie in der Bereitstellungsliste auf Nginx, um detailliertere Informationen anzuzeigen und die Nginx-Bereitstellung (Bereitstellung) zu verwalten.
- Gehen Sie zurück zur Seite „Plattformverwaltung“ – „Clusterverwaltung“, klicken Sie auf der linken Seite der Clusterverwaltungsseite auf „Anwendungslast“ und dann auf „Dienst“. Standardmäßig werden alle Workloads vom Typ „ Service“ angezeigt.
Wir verwenden das Administratorkonto, damit wir alle Arbeitslasten sehen können. Geben Sie „nginx“ in das Suchfeld ein und es werden nur die Arbeitslasten des Nginx-Dienstes angezeigt.
- Klicken Sie in der Dienstliste auf Nginx, um detailliertere Informationen anzuzeigen und Nginx-Dienste zu verwalten (Dienst).
Bisher haben wir die Bereitstellung des Nginx-Webservers im Kubernetes-Cluster implementiert und die Details der bereitgestellten Bereitstellung, des Pods und des Dienstes über die KubeSphere-Verwaltungskonsole angezeigt und überprüft.
häufiges Problem
SSH-Verbindungsfehler
- Fehlermeldung
# ssh 服务器时报错如下
ssh: connect to host 192.168.9.91 port 22: Connection refused
- Lösung
# 问题原因 ubuntu 服务器默认安装后 openssh 服务启动失败, 需要执行如下命令后再启动 sshd 服务
# 切换到 root 用户
sudo -i
# 执行命令
ssh-keygen -A
# 启动 sshd 服务
systemctl start sshd
Abschluss
In diesem Artikel wird hauptsächlich der detaillierte Prozess der Verwendung von KubeKey zur automatischen Bereitstellung von KubeSphere- und Kubernetes-Hochverfügbarkeitsclustern auf drei Ubuntu 22.04-Servern vorgestellt.
Nach Abschluss der Bereitstellung verwenden wir außerdem die KubeSphere-Verwaltungskonsole und die kubectl-Befehlszeile, um den Status der KubeSphere- und Kubernetes-Cluster anzuzeigen und zu überprüfen.
Am Ende überprüften wir die Verfügbarkeit des Kubernetes-Clusters und von KubeSphere, indem wir den Nginx-Webserver auf dem Kubenetes-Cluster bereitstellten, und lernten die grundlegende Verwendung von KubeSphere kennen, indem wir die Vorgänge des Nginx-Pods und den Dienststatus in der KubeSphere-Verwaltungskonsole betrachteten.
Dieser Artikel wurde von OpenWrite veröffentlicht, einer Multi-Post-Plattform zum Bloggen !