Kubernetes ist eine führende Software in der Container-Orchestrierung. Kubernetes funktioniert durch die Verwaltung von Clustern, bei denen es sich einfach um eine Reihe von Hosts handelt, die zum Ausführen von containerisierten Anwendungen bestimmt sind. Für einen Kubernetes-Cluster benötigen Sie mindestens zwei Knoten – einen Master-Knoten und einen Worker-Knoten . Natürlich können Sie den Cluster erweitern, indem Sie beliebig viele Worker-Knoten hinzufügen.
In diesem Leitfaden werden wir einen Kubernetes-Cluster bereitstellen, der aus zwei Knoten besteht, auf denen beide Ubuntu 20.04 Focal Fossa ausführen. Zwei Knoten in unserem Cluster zu haben, ist die einfachste mögliche Konfiguration, aber Sie können diese Konfiguration skalieren und bei Bedarf weitere Knoten hinzufügen.
In diesem Tutorial lernen Sie:
- So installieren Sie Docker
- So installieren Sie Kubernetes
- So konfigurieren Sie einen Master- und Worker-Knoten
- So verbinden 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 auf Ubuntu 20.04 Focal Fossa | Kategorie | Anforderungen, Konventionen oder verwendete Softwareversion |
|---|---|
| System | Ubuntu 20.04 installiert oder Ubuntu 20.04 Focal Fossa aktualisiert |
| Software | Kubernetes |
| Andere | Privilegierter Zugriff auf Ihr Linux-System als root oder über sudo Befehl. |
| Konventionen | # – erfordert, dass bestimmte Linux-Befehle mit Root-Rechten ausgeführt werden, entweder direkt als Root-Benutzer oder durch Verwendung von sudo Befehl$ – erfordert, dass bestimmte Linux-Befehle als normaler, nicht privilegierter Benutzer ausgeführt werden |
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 anhand seines Hostnamens kubernetes-master identifiziert werden . Der zweite Knoten wird unser Worker-Knoten sein und den Hostnamen kubernetes-worker haben .
Der Master-Knoten stellt einen Kubernetes-Cluster bereit und der Worker-Knoten tritt ihm einfach bei. Da Kubernetes-Cluster darauf ausgelegt sind, containerisierte Software auszuführen, werden wir, nachdem wir unseren Cluster zum Laufen gebracht haben, einen Nginx-Server-Container als Konzeptnachweis 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 Worker-Knoten ein, um Docker zu installieren:
$ sudo apt update$ sudo apt install docker.io
Verwenden Sie nach Abschluss der Docker-Installation die folgenden Befehle, um den Dienst zu starten und sicherzustellen, dass er nach jedem Neustart automatisch gestartet wird:
$ sudo systemctl docker starten$ sudo systemctl docker aktivieren
Kubernetes installieren
Jetzt können wir Kubernetes installieren. Stellen Sie wie bei allen anderen Befehlen bis zu diesem Punkt sicher, dass Sie dies auf beiden Knoten tun. Installieren Sie auf Ihrem Kubernetes-Master und -Worker zuerst apt-transport-https Paket, 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 hinzufügen
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 aktualisiert werden zu focal .
$ 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 wird sich weigern zu funktionieren, wenn Ihr System Auslagerungsspeicher verwendet. Bevor Sie fortfahren, vergewissern Sie sich, dass der Auslagerungsspeicher des Master- und Worker-Knotens mit diesem Befehl deaktiviert ist:
$ sudo swapoff -a
Dieser Befehl deaktiviert den Auslagerungsspeicher bis zum Neustart Ihres Systems. Damit diese Änderung bestehen bleibt, verwenden Sie Nano oder Ihren bevorzugten Texteditor, um diese Datei zu öffnen:
$ sudo nano /etc/fstab
Kommentieren Sie in dieser Datei /swapfile aus Zeile, indem Sie ihr ein # voranstellen Symbol, wie unten zu sehen. Schließen Sie dann diese Datei und speichern Sie die Änderungen.
Fügen Sie # hinzu, um die Zeile der Auslagerungsdatei auszukommentieren Hostnamen festlegen
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 nicht bemerken, bis Sie ein neues öffnen. Stellen Sie schließlich sicher, dass alle Ihre Knoten eine genaue Zeit und ein genaues Datum haben, da Sie sonst Probleme mit ungültigen TLS-Zertifikaten bekommen.
Kubernetes-Masterserver initialisieren
Jetzt können wir den Kubernetes-Masterknoten initialisieren. Geben Sie dazu auf Ihrem Master-Knoten den folgenden Befehl ein:
kubernetes-master:~$ sudo kubeadm init
Kubernetes auf Ubuntu 20.04-Master-Knoten ist jetzt initialisiert
Der Kubernetes-Masterknoten wurde nun initialisiert. Die Ausgabe gibt uns einen kubeadm join Befehl, den wir später verwenden müssen, um unsere Worker-Knoten mit dem Master-Knoten zu verbinden. Notieren Sie sich diesen Befehl also für später.
Die Ausgabe von oben rät uns auch, mehrere Befehle als normaler Benutzer auszuführen, um mit der Verwendung des Kubernetes-Clusters zu beginnen. Führen Sie diese drei Befehle auf dem Master-Knoten aus:
kubernetes-master:~$ mkdir -p $HOME/.kubekubernetes-master:~$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/configkubernetes-master:~$ sudo chown $( id -u):$(id -g) $HOME/.kube/config
Stellen Sie ein Pod-Netzwerk bereit
Der nächste Schritt ist die Bereitstellung eines Pod-Netzwerks. Das Pod-Netzwerk wird für die Kommunikation zwischen Hosts verwendet und ist für das ordnungsgemäße Funktionieren des Kubernetes-Clusters erforderlich. Dazu verwenden wir das Flanell-Pod-Netzwerk. Geben Sie die folgenden zwei Befehle auf dem Master-Knoten aus:
kubernetes-master:~$ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.ymlkubernetes-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 aktiviert ist. Sie können den kubectl verwenden Befehl, um zu bestätigen, dass alles eingerichtet und bereit ist:
kubernetes-master:~$ kubectl get pods --all-namespaces
Das Pod-Netzwerk wurde erfolgreich bereitgestellt Wenn in der gesamten STATUS-Spalte „Wird ausgeführt“ angezeigt wird, ist dies ein Hinweis darauf, dass die Bereitstellung abgeschlossen und einsatzbereit ist.
Treten Sie dem Kubernetes-Cluster bei
Jetzt ist unser Cluster bereit für den Beitritt der Worker-Knoten. Verwenden Sie den kubeadm join Befehl, 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:72ad481cee4918cf2314738419356c9a402fb648263Worker-Knoten mit Kubernetes-Cluster verbinden
Bestätigen Sie auf Ihrem Kubernetes-Master-Knoten, dass
kubernetes-workerist jetzt Teil unseres Kubernetes-Clusters mit diesem Befehl:kubernetes-master:~$ kubectl erhält KnotenZeigt an, welche Knoten sich derzeit im Kubernetes-Cluster befinden
Einen Dienst auf einem Kubernetes-Cluster bereitstellen
Jetzt können wir einen Dienst im Kubernetes-Cluster bereitstellen. 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 exponiert Bereitstellung nginx-server --port=80 --name=nginx-httpSie sollten jetzt einen neuen Nginx-Docker-Container sehen, der auf Ihrem Worker-Knoten bereitgestellt wird:
kubernetes-worker:~$ sudo docker psDer neue Docker-Nginx-Container ist auf dem Kubernetes-Worker-Knoten betriebsbereit
Mit dem folgenden Befehl, der vom Kubernetes-Maser-Knoten ausgegeben wird, können Sie eine laufende Liste aller verfügbaren Dienste anzeigen, die in Ihrem Cluster ausgeführt werden:
kubernetes-master:~$ kubectl get svcZeigt an, welche containerisierten Dienste auf dem Kubernetes-Cluster ausgeführt werden
Schlussfolgerung
In diesem Artikel haben wir gelernt, wie man Kubernetes einrichtet, um containerisierte Anwendungen auf Ubuntu 20.04 Focal Fossa bereitzustellen. Wir richten einen einfachen Cluster ein, der aus zwei Hosts besteht, einem Master und einem Worker, obwohl dieser bei Bedarf auf viele weitere Worker-Knoten skaliert werden kann.
Wir haben gesehen, wie man Docker und andere Voraussetzungen konfiguriert und als Proof of Concept einen Nginx-Server in unserem neuen Cluster bereitstellt. Natürlich kann dieselbe Konfiguration verwendet werden, um eine beliebige Anzahl von containerisierten Anwendungen bereitzustellen.