Kubernetes Cluster auf Ubuntu 22.04 einrichten

von howtoforge · April 4, 2024

Kubernetes ist ein kostenloses Container-Orchestrierungstool, das dir bei der automatischen Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen hilft. Ein Kubernetes-Cluster besteht aus einem Master-Knoten und einem Worker-Knoten. Der Master Node ist für die Verwaltung der Nodes und Pods im Cluster zuständig. Der Worker Node wird für die Bereitstellung der Anwendungslast verwendet. Mit Kubernetes kannst du Cloud-native Anwendungen auf einer lokalen Infrastruktur oder auf öffentlichen Cloud-Plattformen bereitstellen und verwalten.

Diese Anleitung zeigt dir, wie du den Kubernetes-Cluster auf einem Ubuntu 22.04 Server einrichtest.

Voraussetzungen

Ein Server, auf dem Ubuntu 22.04 läuft.
Ein Root-Passwort ist auf dem Server konfiguriert.

Erste Schritte

Als Erstes musst du deine Systempakete aktualisieren und auf die neueste Version upgraden. Das kannst du mit dem folgenden Befehl tun:

apt update -y
apt upgrade -y

Sobald alle Pakete aktualisiert sind, musst du auch den Swap auf deinem System deaktivieren. Du kannst ihn mit dem folgenden Befehl deaktivieren:

swapoff -a

Als Nächstes musst du einige erforderliche Kernel-Module auf allen Knoten laden. Dazu bearbeitest du die Datei /etc/modules-load.d/containerd.conf:

nano /etc/modules-load.d/containerd.conf

Füge die folgenden Zeilen hinzu:

overlay
br_netfilter

Speichere und schließe die Datei und lade dann die Module mit dem folgenden Befehl:

modprobe overlay
modprobe br_netfilter

Als Nächstes musst du eine Fine erstellen und einige erforderliche Kernelparameter definieren:

nano /etc/sysctl.d/kubernetes.conf

Füge die folgenden Zeilen hinzu:

net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1

Speichere und schließe die Datei und führe dann den folgenden Befehl aus, um die Änderungen zu übernehmen:

sysctl --system

Containerd installieren

Als Nächstes musst du den Containerd für den Kubernetes-Cluster installieren. Installiere zunächst alle erforderlichen Abhängigkeiten mit dem folgenden Befehl:

apt install curl gnupg2 software-properties-common apt-transport-https ca-certificates -y

Nachdem du alle Abhängigkeiten installiert hast, fügst du das Docker-Repository mit dem folgenden Befehl hinzu:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmour -o /etc/apt/trusted.gpg.d/docker.gpg
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Als Nächstes aktualisierst du das Repository und installierst den Containerd mit dem folgenden Befehl:

apt update -y
apt install containerd.io -y

Als Nächstes musst du den Containerd so konfigurieren, dass er von systemd gestartet wird. Das kannst du mit folgendem Befehl tun:

containerd config default | tee /etc/containerd/config.toml >/dev/null 2>&1
sed -i 's/SystemdCgroup \= false/SystemdCgroup \= true/g' /etc/containerd/config.toml

Starte anschließend den Containerd-Dienst neu, um die Änderungen zu übernehmen:

systemctl restart containerd

Kubernetes-Komponenten installieren

Standardmäßig sind die Kubernetes-Komponenten nicht im Standard-Repository von Ubuntu enthalten. Daher musst du das Kubernetes-Repository zu deinem System hinzufügen. Du kannst es mit dem folgenden Befehl hinzufügen:

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"

Als Nächstes aktualisierst du das Repository und installierst alle Kubernetes-Komponenten mit dem folgenden Befehl:

apt update -y
apt install kubelet kubeadm kubectl -y

Sobald alle Pakete installiert sind, kannst du mit dem nächsten Schritt fortfahren.

Kubernetes Cluster initialisieren

Zu diesem Zeitpunkt sind alle Kubernetes-Komponenten installiert. Führe nun den folgenden Befehl auf dem Master-Knoten aus, um den Cluster zu initialisieren:

kubeadm init --control-plane-endpoint=kubernetes-master-ip

Du erhältst die folgende Ausgabe:

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of control-plane nodes by copying certificate authorities
and service account keys on each node and then running the following as root:

  kubeadm join kubernetes-master-ip:6443 --token chmz7m.fbjgdcqne1q0ff4t \
	--discovery-token-ca-cert-hash sha256:c614bf14af27472e470546539a9a2ff63e5d558dbbb3cc06d6f7a030fcb55426 \
	--control-plane 

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join kubernetes-master-ip:6443 --token chmz7m.fbjgdcqne1q0ff4t \
	--discovery-token-ca-cert-hash sha256:c614bf14af27472e470546539a9a2ff63e5d558dbbb3cc06d6f7a030fcb55426

Hinweis: Kopiere den Befehl kubeadm join aus der obigen Ausgabe. Du musst diesen Befehl auf dem Worker-Knoten ausführen, um dem Cluster beizutreten. Als nächstes musst du die folgenden Befehle ausführen, um mit dem Kubernetes-Cluster zu interagieren:

mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config

Worker-Knoten dem Cluster beitreten

Melde dich beim Worker Node an und führe den folgenden Befehl aus, um den Worker Node in den Kubernetes-Cluster einzubinden:

kubeadm join kubernetes-master-ip:6443 --token chmz7m.fbjgdcqne1q0ff4t --discovery-token-ca-cert-hash sha256:c614bf14af27472e470546539a9a2ff63e5d558dbbb3cc06d6f7a030fcb55426

Du erhältst die folgende Ausgabe:

[preflight] Running pre-flight checks
	[WARNING SystemVerification]: missing optional cgroups: blkio
[preflight] Reading configuration from the cluster...
[preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -o yaml'
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Starting the kubelet
[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

Calico Pod Network Add-on installieren

Als nächstes musst du das Calico Pod Network auf dem Kubernetes Master Node installieren, um das Netzwerk zu verwalten.

Du kannst es mit dem folgenden Befehl herunterladen und installieren:

curl https://projectcalico.docs.tigera.io/manifests/calico.yaml -O calico.yaml
kubectl apply -f calico.yaml

Du erhältst die folgende Ausgabe:

poddisruptionbudget.policy/calico-kube-controllers created
serviceaccount/calico-kube-controllers created
serviceaccount/calico-node created
configmap/calico-config created
customresourcedefinition.apiextensions.k8s.io/bgpconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgppeers.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/blockaffinities.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/caliconodestatuses.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/clusterinformations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/felixconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/hostendpoints.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamblocks.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamconfigs.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamhandles.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ippools.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipreservations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/kubecontrollersconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networksets.crd.projectcalico.org created
clusterrole.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrole.rbac.authorization.k8s.io/calico-node created
clusterrolebinding.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrolebinding.rbac.authorization.k8s.io/calico-node created

Als Nächstes überprüfst du den Status der Pods mit folgendem Befehl:

kubectl get pods -n kube-system

Du erhältst die folgende Ausgabe:

NAME                                            READY   STATUS    RESTARTS   AGE
calico-kube-controllers-58dbc876ff-nh2st        1/1     Running   0          5m58s
calico-node-7cfz7                               1/1     Running   0          5m58s
calico-node-lt5cv                               1/1     Running   0          5m58s
coredns-565d847f94-dm6qc                        1/1     Running   0          21m
coredns-565d847f94-zhng9                        1/1     Running   0          21m
etcd-k8smaster.example.net                      1/1     Running   0          22m
kube-apiserver-k8smaster.example.net            1/1     Running   0          22m
kube-controller-manager-k8smaster.example.net   1/1     Running   0          22m
kube-proxy-9w2xp                                1/1     Running   0          14m
kube-proxy-gdb97                                1/1     Running   0          21m
kube-scheduler-k8smaster.example.net            1/1     Running   0          22m

Du kannst nun den Status des Kubernetes-Clusters mit folgendem Befehl überprüfen:

kubectl get nodes

Du solltest sehen, dass sowohl der Master- als auch der Worker-Knoten den Status ready haben:

NAME                    STATUS   ROLES           AGE   VERSION
k8smaster.example.net   Ready    control-plane   22m   v1.25.0
kubernetes              Ready              14m   v1.25.0

Eine Nginx-Anwendung auf Kubernetes bereitstellen

Um Kubernetes zu testen, werden wir eine Nginx-Anwendung auf dem Cluster bereitstellen.

Führe den folgenden Befehl aus, um eine Nginx-Anwendung einzurichten:

kubectl create deployment nginx-app --image=nginx --replicas=2

Du kannst deine Anwendung mit folgendem Befehl überprüfen:

kubectl get deployment nginx-app

Du erhältst die folgende Ausgabe:

NAME        READY   UP-TO-DATE   AVAILABLE   AGE
nginx-app   2/2     2            2           13s

Als Nächstes stellst du deine Anwendung auf Port 80 mit folgendem Befehl bereit:

kubectl expose deployment nginx-app --type=NodePort --port=80

Als Nächstes überprüfst du den Status des Nginx-Dienstes mit dem folgenden Befehl:

kubectl get svc nginx-app

Du erhältst die folgende Ausgabe:

NAME        TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
nginx-app   NodePort   10.109.89.196           80:30921/TCP   14s

Du kannst die detaillierten Informationen zu deiner Nginx-Anwendung auch mit folgendem Befehl einsehen:

kubectl describe svc nginx-app

Du solltest die folgende Ausgabe sehen:

Name:                     nginx-app
Namespace:                default
Labels:                   app=nginx-app
Annotations:              
Selector:                 app=nginx-app
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.109.89.196
IPs:                      10.109.89.196
Port:                       80/TCP
TargetPort:               80/TCP
NodePort:                   30921/TCP
Endpoints:                192.168.192.129:80,192.168.192.130:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:

Notiere dir jetzt die IP-Adresse der Nginx-Anwendung aus der obigen Ausgabe und überprüfe deine Nginx-Anwendung mit dem Befehl curl:

curl http://10.109.89.196

Wenn alles in Ordnung ist, erhältst du die folgende Ausgabe:

<!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>

Herzlichen Glückwunsch! Du hast den Kubernetes-Cluster erfolgreich auf dem Ubuntu 22.04 Server eingerichtet.

Kubernetes Cluster auf Ubuntu 22.04 einrichten

Voraussetzungen

Erste Schritte

Containerd installieren

Kubernetes-Komponenten installieren

Kubernetes Cluster initialisieren

Worker-Knoten dem Cluster beitreten

Calico Pod Network Add-on installieren

Eine Nginx-Anwendung auf Kubernetes bereitstellen

Das könnte dich auch interessieren …

Suche

Seiten

Kubernetes Cluster auf Ubuntu 22.04 einrichten

Voraussetzungen

Erste Schritte

Containerd installieren

Kubernetes-Komponenten installieren

Kubernetes Cluster initialisieren

Worker-Knoten dem Cluster beitreten

Calico Pod Network Add-on installieren

Eine Nginx-Anwendung auf Kubernetes bereitstellen

Das könnte dich auch interessieren …

Linux cd Befehl Tutorial für Anfänger (9 Beispiele)

So installierst du Terraform auf AlmaLinux 8, CentOS 8 und Rocky Linux 8

Installieren und Konfigurieren des FreeIPA-Servers unter CentOS 8

Suche

Seiten