Implementierung des Aufbaus eines Kubernetes-Clusters mit VirtualBox+Ubuntu16

Der Beginn des Betriebs und der Wartung von Kubernetes ist natürlich untrennbar mit dem Aufbau einer Clusterumgebung verbunden. Dieser Artikel beschreibt den gesamten Prozess des Aufbaus von Kubernetes auf einer Maschine mit VirtualBox + Ubuntu 16, einschließlich einiger aufgetretener Probleme und ihrer Lösungen.

Über Kubernetes

Hier ist eine Erklärung zu Kubernetes aus Wikipedia:

Kubernetes (oft als K8s bezeichnet) ist ein Open-Source-System zum automatischen Bereitstellen, Skalieren und Verwalten von Containeranwendungen. Das System wurde von Google entwickelt und der Cloud Native Computing Foundation (jetzt Teil der Linux Foundation) zur Nutzung gespendet.
Ziel ist es, „eine Plattform für die Automatisierung der Bereitstellung, Skalierung und Ausführung von Anwendungscontainern über Hostcluster hinweg“ bereitzustellen. Es unterstützt eine Reihe von Container-Tools, einschließlich Docker.

Kubernetes kann uns Diensterkennung und Lastausgleich, Speicherorchestrierung, automatische Bereitstellung und Rollback, automatische Vervollständigung des Box-Packings, Selbstheilung sowie Schlüssel- und Konfigurationsverwaltungsfunktionen bieten.

Grundlegende Umgebungsvorbereitung

Installieren Sie VirtualBox

VirtualBox ist eine leistungsstarke virtuelle Maschinensoftware, die Open Source und kostenlos ist. Hier ist die Download-Adresse. Die Installation von VirtualBox ist sehr einfach, daher werde ich hier nicht ins Detail gehen.

Laden Sie das Ubuntu 16-Systemabbild herunter

Hier habe ich Ubuntu 16 als Systemabbild gewählt. Natürlich können Sie auch andere Systeme wie CentOS usw. verwenden. Downloadadresse von Ubuntu 16.

Virtuelle Maschine x3

Nachdem wir VirtualBox installiert und das Ubuntu 16-Image heruntergeladen haben, müssen wir zunächst drei virtuelle Ubuntu 16-Maschinen erstellen. Der Vorgang zum Erstellen einer neuen virtuellen Maschine ist relativ einfach. Befolgen Sie einfach die Schritte nacheinander. Nachdem die Neuanlage abgeschlossen ist, müssen wir jede virtuelle Maschine entsprechend konfigurieren. Der bei der Konfiguration verwendete Benutzer sollte der Root-Benutzer sein.

IP der virtuellen Maschine

Da wir virtuelle Maschinen verwenden, konfigurieren wir für jede virtuelle Maschine eine Netzwerkkarte, damit jede virtuelle Maschine auf das Internet zugreifen kann. Es gibt zwei Möglichkeiten:

• Bei Verwendung einer überbrückten Netzwerkkarte befindet sich die IP jeder virtuellen Maschine im Host-Netzwerksegment und unterstützt virtuelle Maschinen beim Zugriff auf das Internet
• Verwenden Sie NAT-Netzwerk + Portweiterleitung, legen Sie das Netzwerksegment selbst fest und unterstützen Sie den Internetzugang virtueller Maschinen

Mit jeder dieser Methoden können Sie eine Netzwerkkarte für die virtuelle Maschine konfigurieren, sodass die virtuelle Maschine auf das Internet zugreifen kann.

Es ist zu beachten, dass nach dem Erstellen des Clusters die IP-Adresse jedes Knotens im Cluster unverändert bleiben muss, da der Knoten andernfalls erneut verbunden werden muss.

Der einfache Weg besteht darin, die virtuelle Maschine in den Ruhemodus zu versetzen, anstatt sie herunterzufahren, und sie dann beim nächsten Mal aufzuwecken.

Im Cluster verwenden wir die Intranetadresse. Sie können die Intranetadresse jeder virtuellen Maschine über ifconfig oder IP-Adresse finden:

> ifconfig

enp0s3 Link encap:Ethernet HWaddr 08:00:27:6f:23:2a  
          Inet-Adresse: 10.0.2.4 Bcast: 10.0.2.255 Maske: 255.255.255.0
          inet6 Adresse: fe80::a00:27ff:fe6f:232a/64 Bereich: Link
          UP BROADCAST RUNNING MULTICAST MTU:1500 Metrik:1
          RX-Pakete: 3277016 Fehler: 0 verloren: 0 Überläufe: 0 Frame: 0
          TX-Pakete: 3385793 Fehler: 0 verloren: 0 Überläufe: 0 Träger: 0
          Kollisionen:0 txqueuelen:1000 
          RX-Bytes: 1084480916 (1,0 GB) TX-Bytes: 2079122979 (2,0 GB)

Die Adresse dieser virtuellen Maschine (Master) ist 10.0.2.4.

Konfigurieren des Hostnamens

Der Knotenname von Kubernetes wird durch den Hostnamen bestimmt, sodass wir die Hostnamen der drei virtuellen Maschinen jeweils auf Master, Knoten1 und Knoten2 festlegen können. Um den Hostnamen zu ändern, ändern Sie die Datei /etc/hosts und starten Sie die virtuelle Maschine neu:

# /etc/hosts
10.0.2.4 Master
10.0.2.5 Knoten1
10.0.2.6 Knoten2

Unverschlüsselte SSH-Verbindung

Nachdem die virtuellen Maschinen ausgeführt werden, müssen wir zunächst die drei virtuellen Maschinen verbinden, d. h. eine kennwortfreie SSH-Verbindung konfigurieren.
Generieren Sie zunächst öffentliche und private SSH-Schlüssel auf einer der virtuellen Maschinen:

ssh-keygen -t rsa -C '[email protected]' -f ~/.ssh/id_rsa -q -N ''

Parameterbeschreibung von ssh-keygen:

• -t rsa gibt den Verschlüsselungsalgorithmus als RSA an
• -C „[email protected]“ wird verwendet, um einen Hinweis bereitzustellen, der angibt, wer den privaten Schlüssel generiert hat
• -f ~/.ssh/id_rsa gibt den Speicherort an, an dem der private Schlüssel generiert wird
• -q -N '' bedeutet, den privaten Schlüssel nicht zu verschlüsseln und den stillen Modus zu verwenden

Verteilen Sie die öffentlichen und privaten Schlüssel an die anderen beiden virtuellen Maschinen, schreiben Sie den Inhalt des öffentlichen Schlüssels (~/.ssh/id_rsa.pub) in die Datei ~/.ssh/authorized_keys auf allen drei virtuellen Maschinen und setzen Sie die Berechtigungen der Datei ~/.ssh/authorized_keys auf 400:

cat ~/.ssh/id_rsa.pub >> ~/.ssh/autorisierte_schlüssel
chmod 400 ~/.ssh/authorized_keys

Nachdem die Konfiguration abgeschlossen ist, können wir auf einer der virtuellen Maschinen auf folgende Weise eine Verbindung zu einer anderen virtuellen Maschine herstellen:

# Auf dem Masterknoten, ssh root@node1

Aufbau eines Kubernetes-Clusters

Nachdem wir die drei virtuellen Maschinen eingerichtet haben, können wir mit dem Aufbau eines Kubernetes-Clusters mit drei Knoten beginnen.

Docker installieren

apt-get update -y
apt-get install -y \
  apt-transport-https \
  CA-Zertifikate \
  Locke \
  gnupg \
  LSB-Veröffentlichung
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stabil" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# DOCKER ENGINE INSTALLIEREN
apt-get update -y
apt-get install -y docker-ce docker-ce-cli containerd.io

# Konfigurieren Sie Docker so, dass es beim Booten startet
systemctl aktiviere docker.service
systemctl aktiviere containerd.service

# Docker starten
systemctl starte Docker

Installieren Sie kubeadm, kubelet und kubectl

Die hier verwendete Bildquelle ist Alibaba Cloud:

# Aktualisieren Sie den Apt-Paketindex und installieren Sie die Pakete, die zur Verwendung des Kubernetes-Apt-Repositorys erforderlich sind. apt-get update -y
apt-get install -y apt-transport-https ca-zertifikate curl

# Öffentlichen Signaturschlüssel von Google Cloud herunterladen# curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
curl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key hinzufügen -

# Kubernetes-Apt-Repository hinzufügen# echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
echo „deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main“ | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Aktualisieren Sie den apt-Paketindex, installieren Sie kubelet, kubeadm und kubectl und sperren Sie deren Versionen apt-get update -y
apt-get install -y kubelet kubeadm kubectl
apt-mark hold kubelet kubeadm kubectl

SWAP deaktivieren

Bearbeiten Sie die Datei /etc/fstab und kommentieren Sie die Konfiguration der Swap-Partition aus:

#/dev/mapper/master--vg-swap_1 keine Swap-SW 0 0

Laden Sie das Bild vorab herunter

Holen Sie sich die von kubeadm init benötigte Spiegelliste:

> Liste der kubeadm-Konfigurationsbilder

k8s.gcr.io/kube-apiserver:v1.21.1
k8s.gcr.io/kube-controller-manager:v1.21.1
k8s.gcr.io/kube-scheduler:v1.21.1
k8s.gcr.io/kube-proxy:v1.21.1
k8s.gcr.io/pause:3.4.1
k8s.gcr.io/etcd:3.4.13-0
k8s.gcr.io/coredns/coredns:v1.8.0

Die Bildquelle von k8s ist für inländische Benutzer unerreichbar, aber wir können sie zunächst in das inländische oder verwendbare Bildlager ziehen, beispielsweise den Container-Bilddienst ACR von Alibaba Cloud und das offizielle Bildlager DockerHub von Docker.

Wir können mit nur einer Docker-Datei ein neues GitHub-Code-Repository erstellen. Der Inhalt sieht wie folgt aus:

VON k8s.gcr.io/kube-apiserver:v1.21.0

Erstellen Sie dann ein neues Image im Container-Image-Dienst ACR von Alibaba Cloud und verknüpfen Sie es mit dem GitHub-Code-Repository. Das erstellte Image ist das gewünschte K8S-Image, z. B. k8s.gcr.io/kube-apiserver:v1.21.1 oben, aber Sie müssen das Image bei der Verwendung neu benennen.

Nachdem Sie alle erforderlichen Bilder in ACR erstellt haben, können Sie die Bilder mithilfe des folgenden Skripts schnell mit dem Taggen versehen:

# Bilder aus dem Aliyun-Register abrufen
Liste der kubeadm-Konfigurationsbilder | sed -e ‚s/^/docker pull /g‘ -e ‚s#k8s.gcr.io#registry.cn-shenzhen.aliyuncs.com/k8scat#g‘ -e ‚s#/coredns/coredns#/coredns#g‘ | sh -x

# Bilder taggen
Docker-Bilder | grep k8scat | awk '{print "Docker-Tag",$1":"$2,$1":"$2}' | sed -e ‚s#registry.cn-shenzhen.aliyuncs.com/k8scat#k8s.gcr.io#2' | sh -x
Docker-Tag k8s.gcr.io/coredns:v1.8.0 k8s.gcr.io/coredns/coredns:v1.8.0

# Bilder entfernen
Docker-Bilder | grep k8scat | awk '{print "docker rmi",$1":"$2}' | sh -x

Initialisieren Sie den Masterknoten

10.0.2.4 ist die IP-Adresse des Masterknotens. Stellen Sie das Pod-Netzwerksegment auf 192.168.16.0/20 ein:

> kubeadm init --apiserver-advertise-address=10.0.2.4 --pod-network-cidr=192.168.16.0/20

kubeadm join 10.0.2.4:6443 --token ioshf8.40n8i0rjsehpigcl \
    --discovery-token-ca-cert-hash sha256:085d36848b2ee8ae9032d27a444795bc0e459f54ba043500d19d2c6fb044b065

Knoten hinzufügen

kubeadm join 10.0.2.4:6443 --token ioshf8.40n8i0rjsehpigcl \
    --discovery-token-ca-cert-hash sha256:085d36848b2ee8ae9032d27a444795bc0e459f54ba043500d19d2c6fb044b065

Verteilen Sie kubectl-Konfigurationsdateien

scp master:/etc/kubernetes/admin.conf /etc/kubernetes/admin.conf
echo 'export KUBECONFIG="/etc/kubernetes/admin.conf"' >> /etc/Profil
Quelle /etc/Profil

Installieren des Netzwerk-Plugins

Hier verwenden wir Weave Net:

# curl -L "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')" > weave-net.yaml

# Mit IPALLOC_RANGE
kubectl apply -f https://gist.githubusercontent.com/k8scat/c6a1aa5a1bdcb8c220368dd2db69bedf/raw/da1410eea6771c56e93f191df82206be8e722112/k8s-weave-net.yaml

Dies ist das Ende dieses Artikels über die Implementierung des Aufbaus eines Kubernetes-Clusters mit VirtualBox+Ubuntu16. Weitere Informationen zum Aufbau eines Kubernetes-Clusters mit VirtualBox+Ubuntu16 finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!