So installieren Sie Kubernetes unter Ubuntu 20.04

Container sind eine gute Wahl, um unsere eigenen Anwendungen zu bündeln und auszuführen. Wenn die Anzahl der Container schnell zunimmt und diese bequem verwaltet werden müssen. Aus diesem Grund kommt Kubernetes. Kubernetes (K8s) ist ein Open-Source-System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen und Diensten.

Der Kubernetes-Cluster enthält Master- und Worker-Knoten. Der Master-Knoten steuert und verwaltet eine Gruppe von Worker-Knoten. Sie können mehrere Master-Knoten für Hochverfügbarkeitscluster haben.

Diese Anleitung zeigt, wie Sie einen Kubernetes-Cluster installieren mit kubeadm auf Ubuntu 20.04.

Umgebung vorbereiten

• Verwenden Sie 2 Linux-Hosts mit Ubuntu 20.04

Festlegen von statischen IP-Adressen für Master-Knoten und Worker-Knoten

- Masterknoten:192.168.1.11
- Worker-Knoten:192.168.1.12

• Konfigurieren Sie den Hostnamen für jeden Computer

Wir verwenden node-1 als Master und node-2 als Worker-Knoten.

$ sudo hostnamectl set-hostname node-1
$ sudo hostnamectl set-hostname node-2

• Auslagerungsspeicher auf jedem Ubuntu-Knoten deaktivieren

$ sudo swapoff -a

Kubernetes-Repository hinzufügen

Kubernetes ist im Standard-Repository von Ubuntu nicht verfügbar, muss also manuell hinzugefügt werden.

Sowohl auf dem Master- als auch auf dem Worker-Knoten Führen Sie Folgendes aus:

Hinzufügen des Kubernetes-Signaturschlüssels wie folgt:

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

Fügen Sie dann das Kubernetes-Repository hinzu und führen Sie Folgendes aus:

$ echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" >> ~/kubernetes.list
$ sudo mv ~/kubernetes.list /etc/apt/sources.list.d
$ sudo apt update

Kubernetes-Tools installieren

In diesem Abschnitt installieren wir Kubeadm, cri-o, Kubelet und Kubernetes-cni. Alle diese Tools müssen auf Master- und Worker-Knoten installiert werden .

Stellen Sie sicher, dass Sie die empfohlene und unterstützte Version installieren. Hier installieren wir Version 1.18 von Kubernetes und Crio.

Kubeadm installieren

Kubeadm ist ein Tool, das Teil des Kubernetes-Projekts ist und hilft, den Kubernetes-Cluster zu initialisieren.

In diesem Tutorial installieren wir die kubeadm-Version 1.18.0-00, geben Sie Folgendes ein:

$ sudo apt install -y kubeadm=1.18.0-00 --allow-unauthenticated

Hinweis :Sie können die spezifische Version mit dem folgenden Befehl finden:

$ curl -s https://packages.cloud.google.com/apt/dists/kubernetes-xenial/main/binary-amd64/Packages | grep Version | awk '{print $2}'

Kubectl installieren

Kubectl ist das Befehlszeilentool von Kubernetes. Damit können Sie Befehle in den Kubernetes-Clustern ausführen. Sie können kubectl verwenden, um Anwendungen bereitzustellen, Cluster-Ressourcen zu verwalten und Protokolle anzuzeigen.

Installieren Sie kubectl v1.18.0-00 mit dem folgenden Befehl:

$ sudo apt install -y kubectl=1.18.0-00 --allow-unauthenticated

CRI-O installieren

CRI-O ist ein OCI-konformes Container Runtime Interface (CRI). Die am häufigsten verwendete Laufzeitumgebung ist Docker. Ab der Veröffentlichung von Kubernetes 1.20 ist das CRI-Shim (Container Runtime Interface) für Docker veraltet. Docker erzeugt Images, die kein OCI-Image (Open Container Initiative) sind.

Wir sollten eine OCI-kompatible Containerlaufzeit verwenden, um OCI-Images abzurufen und auszuführen, insbesondere wenn Sie Kubernetes-Dienste wie GKE, EKS oder AKS verwenden.

Sie können Docker weiterhin verwenden und dann mit sudo apt-get install docker.io installieren

Hier verwende ich cri-o das ist eine konforme Laufzeit. Sorgen Sie dafür, dass die cri-o-Version mit der Kubernetes-Version übereinstimmt.

Stellen Sie sicher, dass Sie die unterstützte Version installieren.

Verwenden Sie zuerst modprobe Befehl, um das Overlay zu laden und br_netfilter Module sowohl auf dem Master- als auch auf dem Worker-Knoten:

$ sudo modprobe overlay
$ sudo modprobe br_netfilter

Erstellen Sie dann eine sysctl-Konfigurationsdatei, um die IP-Weiterleitung und Netzfiltereinstellungen während des Neustarts zu aktivieren, indem Sie die folgenden Zeilen in /etc/sysctl.d/99-kubernetes-cri.conf einfügen Datei auf Master- und Worker-Knoten:

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

Wenden Sie die Konfigurationsdatei an, indem Sie Folgendes ausführen:

$ sudo sysctl --system

Jetzt geben wir das Ubuntu-Betriebssystem und die Cri-o-Version wie folgt an:

$ sudo -i
# export OS=xUbuntu_20.04
# export VERSION=1.18

Führen Sie dann die folgenden Befehle als root aus Benutzer:

# echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
# echo "deb http://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.list

# curl -L https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable:cri-o:$VERSION/$OS/Release.key | apt-key add -
# curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | apt-key add -

# apt update
# apt install cri-o cri-o-runc

Sobald die Installation abgeschlossen ist, wird die conmon (Container Monitoring) Utility wurde installiert. Finden Sie den Pfad von conmon:

$ which conmon

/usr/bin/conmon

Bearbeiten Sie die /etc/crio/crio.conf Datei wie folgt:

...
# Path to the conmon binary, used for monitoring the OCI runtime.
conmon = "/usr/bin/conmon"         #<-- Edit this line. Around line 108

...

registries = [                     #<-- Edit and add registries. Around line 351
        "docker.io",
        "quay.io",
]
....

Aktivieren Sie cri-o und vergewissern Sie sich, dass es läuft:

$ sudo systemctl daemon-reload
$ sudo systemctl enable crio
$ sudo systemctl start crio
$ sudo systemctl status crio

Ausgabe:

● crio.service - Container Runtime Interface for OCI (CRI-O)
   Loaded: loaded (/usr/lib/systemd/system/crio.service; enabled; vendor preset: enabled)
   Active: active (running) since Thu 2020-12-10 15:46:37 UTC; 3 days ago
     Docs: https://github.com/cri-o/cri-o
...

Kubelet installieren

Kubelet ist ein Agent, der auf jedem Knoten ausgeführt wird und dafür verantwortlich ist, mit dem API-Server auf dem Master-Knoten zu kommunizieren und die Container-Laufzeit zum Starten von Arbeitslasten zu steuern.

Konfigurieren Sie kubelet Um zu verstehen, wie man mit cri-o interagiert, fügen Sie die folgende Zeile in /etc/default/kubelet ein Datei:

KUBELET_EXTRA_ARGS=--feature-gates="AllAlpha=false,RunAsGroup=true" --container-runtime=remote --cgroup-driver=systemd --container-runtime-endpoint='unix:///var/run/crio/crio.sock' --runtime-request-timeout=5m

Führen Sie sowohl auf dem Master- als auch auf dem Worker-Knoten den folgenden Befehl aus, um kubelet zu installieren :

$ sudo apt install -y kubelet=1.18.0-00 --allow-unauthenticated

Kubernetes-cni installieren

Um Containernetzwerke im Cluster zu aktivieren, müssen wir kubernetes-cni installieren .

Führen Sie den folgenden Befehl aus:

$ sudo apt-get install -y kubernetes-cni --allow-unauthenticated

Kubernetes-Cluster bereitstellen

Die Bereitstellung des Kubernetes-Clusters umfasst zwei Schritte. Der erste Schritt wäre, den Master-Knoten zu initialisieren und der zweite Schritt, den Worker-Knoten mit dem Cluster zu verbinden.

Master-Knoten initialisieren

So initialisieren Sie Kubernetes auf dem Master-Knoten , geben Sie Folgendes ein:

$ sudo kubeadm init --apiserver-advertise-address=192.168.1.11 --pod-network-cidr=10.244.0.0/16

Es dauert einige Minuten, bis der Vorgang abgeschlossen ist. Sobald die Initialisierung abgeschlossen ist, zeigt das Terminal die Ausgabe wie folgt an:

Beachten Sie die oben markierte Zeile, um dem Cluster beizutreten, und verwenden Sie sie im nächsten Schritt, um den Worker-Knoten mit dem Cluster zu verbinden.

Führen Sie nun den folgenden Befehl aus, um das Kubernetes-Konfigurationsverzeichnis auf dem Master-Knoten zu erstellen:

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

Stellen Sie als Nächstes ein Pod-Netzwerk für den Cluster bereit:

$ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Überprüfen, ob alle Komponenten der Steuerungsebene erfolgreich installiert wurden:

$ kubectl get pod --all-namespaces

Arbeiterknoten mit Cluster verbinden

Melden Sie sich jetzt beim Worker-Knoten an und fügen Sie den Worker-Knoten dem Cluster hinzu.

Führen Sie auf dem Worker-Knoten-Computer den folgenden Befehl aus:

$ sudo kubeadm join 192.168.1.11:6443 --token 9ii02d.nsmrmu1asascv2yg \
    --discovery-token-ca-cert-hash sha256:1104bf70b03a2d030ffc0a462f9dbcbcdd9975393e9a9ac2a1f18500f1b6b74e

Nachdem der Beitrittsprozess abgeschlossen ist, gehen Sie zurück zum Master-Knoten und führen Sie Folgendes aus:

$ kubectl get node
NAME     STATUS   ROLES    AGE     VERSION
node-1   Ready    master   2m37s   v1.18.0
node-2   Ready    none     22s     v1.18.0

Um weitere Informationen über den Knoten zu erhalten, geben Sie Folgendes ein:

$ kubectl get node -owide
NAME     STATUS   ROLES    AGE   VERSION   INTERNAL-IP   EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION   CONTAINER-RUNTIME
node-1   Ready    master   9h    v1.18.0   10.2.0.4              Ubuntu 20.04.1 LTS   5.4.0-1029-gcp   cri-o://1.18.4
node-2   Ready    none     9h    v1.18.0   10.2.0.5              Ubuntu 20.04.1 LTS   5.4.0-1029-gcp   cri-o://1.18.4

Die Ausgaben zeigen Details des Master-Knotens und der Knoten, die dem Cluster beigetreten sind.

Lesen Sie auch:So installieren Sie Kubernetes lokal mit Vagrant/Minikube

Schlussfolgerung

Da die Containerisierung immer beliebter wird, macht die Notwendigkeit, containerisierte Arbeitslasten und Dienste zu verwalten, Kubernetes so beliebt. Alle großen Cloud-Anbieter haben damit begonnen, Managed Kubernetes zu unterstützen, was das Leben einfacher macht.

Kubernetes ist völlig kostenlos und kann jederzeit aus seinem Repository heruntergeladen werden. Ich hoffe, die Installation von Kubernetes auf Ubuntu hat Ihnen gefallen. Sie können versuchen, Anwendungen wie MySQL oder WordPress auf dem K8-Cluster bereitzustellen.

Vielen Dank fürs Lesen und bitte hinterlassen Sie Ihren Vorschlag im Kommentarbereich unten.