So installieren Sie Kubernetes auf Ubuntu 20.04 Focal Fossa Linux

Kubernetes ist führende Software im Bereich der Container-Orchestrierung. Kubernetes funktioniert durch die Verwaltung von Clustern, bei denen es sich einfach um eine Reihe von Hosts handelt, die für die Ausführung containerisierter Anwendungen gedacht sind. Um einen Kubernetes-Cluster zu haben, benötigen Sie mindestens zwei Knoten – einen Master-Knoten und einen Worker-Knoten. Natürlich können Sie den Cluster erweitern, indem Sie so viele Worker-Knoten hinzufügen, wie Sie benötigen.

In dieser Anleitung stellen wir einen Kubernetes-Cluster bereit, der aus zwei Knoten besteht, auf denen Ubuntu 20.04 Focal Fossa ausgeführt wird. Zwei Knoten in unserem Cluster zu haben, ist die einfachste Konfiguration, aber Sie können diese Konfiguration skalieren und weitere Knoten hinzufügen, wenn Sie möchten.

In diesem Tutorial lernen Sie:

• So installieren Sie Docker
• So installieren Sie Kubernetes
• Konfigurieren eines Master- und Worker-Knotens
• So verknüpfen Sie einen Worker-Knoten mit einem Kubernetes-Cluster
• So stellen Sie Nginx (oder eine beliebige containerisierte Anwendung) in einem Kubernetes-Cluster bereit

Bereitstellen von Kubernetes unter Ubuntu 20.04 Focal Fossa

Szenario

Bevor wir eintauchen, lassen Sie uns die Einzelheiten unseres Szenarios festlegen. Wie oben erwähnt, wird unser Cluster zwei Knoten haben, und auf beiden Knoten wird Ubuntu 20.04 Focal Fossa ausgeführt. Einer wird der Master-Knoten sein und kann leicht mit seinem Hostnamen kubernetes-master identifiziert werden. Der zweite Knoten ist unser Worker-Knoten und hat den Hostnamen kubernetes-worker.

Der Master-Knoten stellt einen Kubernetes-Cluster bereit, und der Worker-Knoten tritt ihm einfach bei. Da Kubernetes-Cluster für die Ausführung von containerisierter Software konzipiert sind, werden wir, nachdem wir unseren Cluster zum Laufen gebracht haben, einen Nginx-Server-Container als Proof of Concept bereitstellen.

Docker installieren

Auf beiden Knoten muss Docker installiert sein, da Kubernetes darauf angewiesen ist. Öffnen Sie ein Terminal, und geben Sie die folgenden Befehle sowohl auf dem Master- als auch auf dem Workerknoten ein, um Docker zu installieren:

sudo apt update
sudo apt install docker.io

Nachdem die Installation von Docker abgeschlossen ist, verwenden Sie die folgenden Befehlsbefehle, um den Dienst zu starten und sicherzustellen, dass er nach jedem Neustart automatisch gestartet wird:

sudo systemctl start docker
sudo systemctl enable docker

Installieren von Kubernetes

Jetzt sind wir bereit, Kubernetes zu installieren. Stellen Sie wie bei allen anderen Befehlen bis zu diesem Punkt sicher, dass Sie dies auf beiden Knoten tun. Installieren Sie zunächst auf Ihrem Kubernetes-Master und -Worker das Paket apt-transport-https, das es uns ermöglicht, http und https in den Repositories von Ubuntu zu verwenden. Jetzt ist auch ein guter Zeitpunkt, um curl zu installieren, da wir es gleich brauchen werden:

sudo apt install apt-transport-https curl

Fügen Sie als Nächstes den Kubernetes-Signaturschlüssel zu beiden Systemen hinzu:

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add

Als Nächstes fügen wir das Kubernetes-Paket-Repository hinzu. Beachten Sie, dass zum Zeitpunkt der Erstellung dieses Artikels Ubuntu 16.04 Xenial Xerus das neueste verfügbare Kubernetes-Repository ist. Dies sollte schließlich durch Ubuntu 20.04 Focal Fossa ersetzt werden, und der folgende Befehl kann dann von xenial auf focal aktualisiert werden.

sudo apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"

Jetzt können wir Kubernetes installieren:

sudo apt install kubeadm kubelet kubectl kubernetes-cni

Auslagerungsspeicher deaktivieren

Kubernetes funktioniert nicht, wenn Ihr System Auslagerungsspeicher verwendet. Bevor Sie fortfahren, stellen Sie sicher, dass der Auslagerungsspeicher für den Master- und Worker-Knoten mit dem folgenden Befehl deaktiviert ist:

sudo swapoff -a

Dieser Befehl deaktiviert den Auslagerungsspeicher, bis Ihre Systeme neu gestartet werden. Um diese Änderung beizubehalten, verwenden Sie nano oder Ihren bevorzugten Texteditor, um diese Datei zu öffnen:

sudo nano /etc/fstab

Kommentieren Sie in dieser Datei die Zeile /swapfile aus, indem Sie ihr ein #-Symbol voranstellen, wie unten gezeigt. Schließen Sie dann diese Datei und speichern Sie die Änderungen.

Fügen Sie # hinzu, um die Auslagerungsdateizeile auszukommentieren

Festlegen von Hostnamen

Stellen Sie als Nächstes sicher, dass alle Ihre Knoten einen eindeutigen Hostnamen haben. In unserem Szenario verwenden wir die Hostnamen kubernetes-master und kubernetes-worker, um unsere Hosts leicht zu unterscheiden und ihre Rollen zu identifizieren. Verwenden Sie den folgenden Befehl, wenn Sie Ihre Hostnamen ändern müssen:

sudo hostnamectl set-hostname kubernetes-master

Und auf dem Worker-Knoten:

sudo hostnamectl set-hostname kubernetes-worker

Sie werden die Änderungen des Hostnamens im Terminal erst bemerken, wenn Sie ein neues Terminal öffnen. Stellen Sie schließlich sicher, dass alle Ihre Knoten eine genaue Uhrzeit und ein genaues Datum haben, da Sie sonst Probleme mit ungültigen TLS-Zertifikaten bekommen.

Initialisieren des Kubernetes-Masterservers

Jetzt sind wir bereit, den Kubernetes-Masterknoten zu initialisieren. Geben Sie dazu den folgenden Befehl auf Ihrem Master-Knoten ein:

kubernetes-master:~$ sudo kubeadm init

Kubernetes auf dem Master-Knoten von Ubuntu 20.04 ist jetzt initialisiert

Der Kubernetes-Master-Knoten wurde nun initialisiert. Die Ausgabe gibt uns einen kubeadm join-Befehl, den wir später verwenden müssen, um unsere(n) Worker-Knoten(s) mit dem Master-Knoten zu verbinden. Notieren Sie sich diesen Befehl also für später.

Die obige Ausgabe rät uns auch, mehrere Befehle als regulärer Benutzer auszuführen, um den Kubernetes-Cluster zu verwenden. Führen Sie diese drei Befehle auf dem Master-Knoten aus:

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

Bereitstellen eines Pod-Netzwerks

Der nächste Schritt ist die Bereitstellung eines Pod-Netzwerks. Das Pod-Netzwerk wird für die Kommunikation zwischen den Hosts verwendet und ist notwendig, damit der Kubernetes-Cluster ordnungsgemäß funktioniert. Hierfür verwenden wir das Flanell-Pod-Netzwerk. Geben Sie die folgenden beiden Befehle auf dem Master-Knoten ein:

kubernetes-master:~$ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
kubernetes-master:~$ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/k8s-manifests/kube-flannel-rbac.yml

Abhängig von Ihrer Umgebung kann es nur wenige Sekunden oder eine Minute dauern, bis das gesamte Flanellnetzwerk hochgefahren ist. Sie können den Befehl kubectl verwenden, um zu bestätigen, dass alles betriebsbereit ist:

kubernetes-master:~$ kubectl get pods --all-namespaces

Das Pod-Netzwerk wurde erfolgreich bereitgestellt

Wenn in der gesamten Spalte STATUS "Wird ausgeführt" angezeigt wird, ist dies ein Hinweis darauf, dass die Bereitstellung abgeschlossen ist und sofort loslegen kann.

Treten Sie dem Kubernetes-Cluster bei

Jetzt ist unser Cluster bereit, die Worker-Knoten zu verbinden. Verwenden Sie den Befehl kubeadm join, der zuvor aus der Initialisierungsausgabe des Kubernetes-Masterknotens abgerufen wurde, um Ihrem Kubernetes-Cluster beizutreten:

kubernetes-worker:~$ sudo kubeadm join 192.168.1.220:6443 --token 1exb8s.2t4k3b5syfc3jfmo --discovery-token-ca-cert-hash sha256:72ad481cee4918cf2314738419356c9a402fb609263adad48c13797d0cba2341

Verknüpfen des Worker-Knotens mit dem Kubernetes-Cluster

Bestätigen Sie mit dem folgenden Befehl auf Ihrem Kubernetes-Masterknoten, dass kubernetes-worker jetzt Teil unseres Kubernetes-Clusters ist:

kubernetes-master:~$ kubectl get nodes

Zeigt an, welche Knoten sich derzeit im Kubernetes-Cluster befinden

Bereitstellen eines Diensts auf einem Kubernetes-Cluster

Jetzt sind wir bereit, einen Dienst im Kubernetes-Cluster bereitzustellen. In unserem Beispiel werden wir als Proof of Concept einen Nginx-Server in unserem neuen Cluster bereitstellen. Führen Sie die folgenden beiden Befehle auf Ihrem Master-Knoten aus:

kubernetes-master:~$ kubectl run --image=nginx nginx-server --port=80 --env="DOMAIN=cluster"
kubernetes-master:~$ kubectl expose deployment nginx-server --port=80 --name=nginx-http

Sie sollten jetzt einen neuen nginx-Docker-Container sehen, der auf Ihrem Worker-Knoten bereitgestellt wurde:

kubernetes-worker:~$ sudo docker ps

Der neue Docker-Nginx-Container wird auf dem Kubernetes-Worker-Knoten ausgeführt

Mit dem folgenden Befehl, der vom Kubernetes-Maser-Knoten ausgegeben wird, sehen Sie eine laufende Liste aller verfügbaren Dienste, die in Ihrem Cluster ausgeführt werden:

kubernetes-master:~$ kubectl get svc

Zeigt an, welche containerisierten Dienste auf dem Kubernetes-Cluster ausgeführt werden

Schlussfolgerung

In diesem Artikel haben wir gelernt, wie Sie Kubernetes einrichten, um containerisierte Anwendungen auf Ubuntu 20.04 Focal Fossa bereitzustellen. Wir richten einen Basis-Cluster ein, der aus zwei Hosts, einem Master und einem Worker, besteht, der jedoch bei Bedarf auf viele weitere Worker-Knoten skaliert werden kann.

Als Proof of Concept haben wir gesehen, wie man Docker und andere Voraussetzungen konfiguriert sowie einen Nginx-Server in unserem neuen Cluster bereitstellt. Natürlich kann dieselbe Konfiguration auch für die Bereitstellung einer beliebigen Anzahl von containerisierten Anwendungen verwendet werden.