So installieren Sie Kubernetes mit Kubeadm

Kubernetes wurde in einem früheren Artikel „Erste Schritte mit Kubernetes auf Amazon Web Services (AWS)“ vorgestellt. Kubernetes wurde auch in einem anderen Artikel diskutiert, „Using Kubernetes (K8s) on IBM Bluemix“. Kubernetes kann für Entwicklungszwecke auf Bare Metal auf fast jedem Betriebssystem installiert werden, einschließlich Fedora, CentOS, Ubuntu und CoreOS.

Das Problem

Die Kubernetes-Installation auf Bare-Metal umfasst die Ausführung mehrerer Befehle zum Einrichten eines Master-Knotens, von Worker-Knoten, eines Pod-Netzwerks und etcd.

Die Lösung

Kubernetes 1.4 führt ein neues Tool namens kubeadm ein zum Bootstrapping eines Kubernetes-Clusters. Der kubeadm bootet einen Kubernetes-Cluster mit zwei Befehlen. Nach der Installation von Docker, kubectl und kubelet kann der Master-Knoten mit kubeadm init gestartet werden und Worker-Knoten, die mit kubeadm join hinzugefügt wurden .

In diesem Artikel verwenden wir das folgende Verfahren, um einen Kubernetes-Cluster zu installieren und zu booten und den Cluster anschließend zu testen:

Starten Sie drei neue Ubuntu-Instances auf Amazon EC2.
Installieren Sie auf allen Ubuntu-Instanzen Docker, kubeadm, kubectl und kubelet.
Initiieren Sie von einer der Ubuntu-Instanzen aus den Kubernetes-Cluster-Master mit dem folgenden Befehl:
```
kubeadm init
```
Wenden Sie die Calico-Pod-Netzwerkrichtlinie kubeadm/calico.yaml an .
Verbinden Sie die anderen beiden Ubuntu-Instanzen (Knoten) mit master mit kubeadm join --token= .
Auf dem Master werden drei Knoten mit „kubectl get nodes“ aufgelistet.

Führen Sie eine Anwendung auf Master aus:

kubectl -s http://localhost:8080 run nginx
   --image=nginx
   --replicas=3 --port=80

Listen Sie die Pods auf:
```
kubectl get pods -o wide
```
Deinstallieren Sie den Kubernetes-Cluster.
```
kubeadm reset
```

Dieser Artikel hat die folgenden Abschnitte:

Einstellung der Umgebung
Installieren von Docker, kubeadm, kubectl und kubelet auf jedem Host
Initialisieren des Masters
Installieren des Calico-Pod-Netzwerks
Knoten mit dem Cluster verbinden
Installieren einer Beispielanwendung
Cluster deinstallieren
Einschränkungen
Weitere Entwicklungen in kubeadm
Schlussfolgerung

Einstellung der Umgebung

Der kubeadm Tool erfordert die folgenden Computer, auf denen Ubuntu 16.04+, HypriotOS v1.0.1+ oder CentOS 7 ausgeführt wird.

Eine Maschine für den Master-Knoten
Ein oder mehrere Computer für die Worker-Knoten

Auf jedem der Computer ist mindestens 1 GB RAM erforderlich. Wir haben drei Ubuntu-Maschinen verwendet, die auf Amazon EC2 ausgeführt werden, um einen Cluster mit einem einzigen Master-Knoten und zwei Worker-Knoten zu booten. Die drei Ubuntu-Rechner sind in Abbildung 1 dargestellt.

Abbildung 1: Ubuntu-Maschinen

Installieren von Docker, kubeadm, kubectl und kubelet auf jedem Host

In diesem Abschnitt installieren wir Docker, kubelet, kubectl und kubeadm auf jeder der drei Maschinen. Die installierten Komponenten werden in Tabelle 1 erläutert.

Komponente	Beschreibung
Docker	Die Containerlaufzeit. Version 1.11.2 wird empfohlen und v1.10.3 und v1.12.1 sind auch in Ordnung. Erforderlich auf allen Computern im Cluster.
kubelet	Die Kernkomponente von Kubernetes, die auf allen Maschinen im Cluster ausgeführt wird. Startet Container und Pods. Erforderlich auf allen Computern im Cluster.
kubectl	Das Befehlszeilentool zum Verwalten eines Clusters. Nur auf dem Master-Knoten erforderlich, aber nützlich, wenn es auf allen Knoten installiert ist.
kubeadm	Das Tool zum Bootstrap eines Clusters. Erforderlich auf allen Computern im Cluster.

Tabelle 1: Zu installierende Komponenten

Rufen Sie die öffentliche IP-Adresse jeder der drei Maschinen ab und melden Sie sich mit SSH bei jeder der Maschinen an:

ssh -i "docker.pem" [email protected]
ssh -i "docker.pem" [email protected]
ssh -i "docker.pem" [email protected]

Die Befehle zum Installieren der Binärdateien müssen als root ausgeführt werden; Setzen Sie daher den Benutzer auf root.

sudo su -

Führen Sie die folgenden Befehle auf jedem der Computer aus:

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg
   | apt-key add -
cat <<EOF > /etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF

Der erste Befehl lädt die erforderlichen Pakete für Kubernetes herunter, wie in der Ausgabe in Abbildung 2 gezeigt.

Abbildung 2: Pakete für Kubernetes herunterladen

Der Befehl 2 lädt die Paketlisten aus den Repositories herunter und aktualisiert sie mit den neuesten Versionen der Pakete.

apt-get update

Die Ausgabe ist in Abbildung 3 dargestellt.

Abbildung 3: Repository-Pakete aktualisieren

Als nächstes installieren Sie Docker:

# Install docker if you don't have it already.
apt-get install -y docker.io

Docker wird installiert, wie in der Befehlsausgabe in Abbildung 4 gezeigt.

Abbildung 4: Docker installieren

Installieren Sie anschließend kubelet (Kernkomponente von Kubernetes), kubeadm (Bootstrapping-Tool), kubectl (Cluster-Verwaltungstool) und kubernetes-cni (Netzwerk-Plugin):

apt-get install -y kubelet kubeadm kubectl kubernetes-cni

Die Ausgabe der vorhergehenden Befehle ist in Abbildung 5 dargestellt.

Abbildung 5: Installieren von kubelet, kubeadm, kubectln und kubernetes-cni

Master initialisieren

Als nächstes initialisieren Sie den Master, auf dem die etcd-Datenbank und der API-Server laufen. Das Kubelet startet Pods, um diese Komponenten auszuführen. Führen Sie den folgenden Befehl aus, der die IP-Adressen automatisch erkennt:

kubeadm init

Wie in der Befehlsausgabe gezeigt, werden zunächst einige Preflight-Checks ausgeführt, um den Systemstatus zu validieren. Anschließend wird ein Master/Tokens-Token generiert, das als gegenseitiger Authentifizierungsschlüssel für Worker-Knoten verwendet werden soll, die dem Cluster beitreten möchten. Als Nächstes werden ein selbstsignierter Zertifizierungsstellenschlüssel und ein Zertifikat generiert, um jedem der Knoten im Cluster Identitäten für die Kommunikation mit den Clients bereitzustellen. Für die Kommunikation mit den Clients werden für den API-Server ein API-Serverschlüssel und ein Zertifikat erstellt. Ein util/kubeconfig -Datei wird erstellt, damit das Kubelet eine Verbindung zum API-Server und einer anderen util/kubeconfig herstellen kann Datei wird für die Verwaltung erstellt. Anschließend wird die API-Client-Konfiguration erstellt. Die Ausgabe von kubeadm init Befehl ist in Abbildung 6 dargestellt.

Abbildung 6: kubeadm init ausführen

Alle Komponenten der Steuerungsebene werden bereit. Der erste Knoten wird bereit und eine Testbereitstellung wird durchgeführt. Die wesentlichen Add-on-Komponenten kube-discovery, kube-proxy und kube-dns werden ebenfalls erstellt, wie in der Befehlsausgabe in Abbildung 7 gezeigt. Der Kubernetes-Master wird erfolgreich initialisiert. Ein Befehl mit der folgenden Syntax wird generiert; es muss auf Computern (Knoten) ausgeführt werden, die dem Cluster beitreten sollen.

kubeadm join -token=<token> <IP Address of the master node>

Der vorhergehende Befehl muss kopiert und für die spätere Verwendung auf Worker-Knoten aufbewahrt werden.

Abbildung 7: Kubernetes-Master initialisiert

Standardmäßig sind die Master-Knoten nicht planbar und werden durch die Verwendung des „dedizierten“ Taints erstellt. Der Master-Knoten kann mit dem folgenden Befehl planbar gemacht werden:

kubectl taint nodes --all dedicated-

Der kubeadm Der Befehl unterstützt einige andere Optionen (siehe Tabelle 2), die wir nicht verwenden mussten, aber verwendet werden könnten, um den Standardbefehl zu überschreiben.

Befehlsparameter	Beschreibung	Standard
`--preflight-checks überspringen`	Überspringt die Preflight-Prüfungen	Preflight-Checks werden durchgeführt
`--use-kubernetes-version`	Legt die zu verwendende Kubernetes-Version fest	v1.5.1
`--api-advertise-addresses`	Der Befehl kubeadm init erkennt und verwendet automatisch die IP-Adresse der Standardnetzwerkschnittstelle und verwendet sie, um Zertifikate für den API-Server zu generieren. Dieser Konfigurationsparameter kann verwendet werden, um den Standard mit einer oder mehreren IP-Adressen zu überschreiben, auf denen der API-Server validiert werden soll.	Automatische Erkennung
`--api-external-dns-names`	Dieser Konfigurationsparameter kann verwendet werden, um die Standardnetzwerkschnittstelle mit einem oder mehreren Hostnamen zu überschreiben, auf denen der API-Server validiert werden soll. Es darf nur eine der IP-Adressen oder externen DNS-Namen verwendet werden.
`--cloud-provider`	Gibt einen Cloud-Anbieter an. Der Cloud-Manager unterstützt „aws“, „azure“, „cloudstack“, „gce“, „mesos“, „openstack“, „ovirt“, „rackspace“ und „vsphere“. Die Konfiguration des Cloud-Anbieters kann in der Datei /etc/kubernetes/cloud-config bereitgestellt werden. Die Verwendung eines Cloud-Anbieters hat auch den Vorteil, dass persistente Volumes und Lastenausgleich verwendet werden.	Keine automatische Erkennung eines Cloud-Anbieters
`--pod-network-cidr`	Weist jedem Knoten Netzwerkbereiche (CIDRs) zu und ist nützlich für bestimmte Netzwerklösungen, einschließlich Flannel- und Cloud-Anbieter.
`--service-cidr`	Überschreibt das Subnetz, das Kubernetes verwendet, um Pods IP-Adressen zuzuweisen. Die `/etc/systemd/system/kubelet.service.d/10-kubeadm.conf` muss ebenfalls geändert werden.	10.96.0.0/12
`--service-dns-domain`	Überschreibt das DNS-Namensuffix für die Zuweisung von Diensten mit DNS-Namen; Er hat das Format `..svc.cluster.local` . Die `/etc/systemd/system/kubelet.service.d/10-kubeadm.conf` muss ebenfalls geändert werden.	`cluster.local`
`--token`	Gibt das Token an, das für die gegenseitige Authentifizierung zwischen dem Master und den dem Cluster beitretenden Knoten verwendet werden soll.	Automatisch generiert

Tabelle 2: Kubeadm-Befehlsoptionen

Installieren des Calico-Pod-Netzwerks

Damit Pods miteinander kommunizieren können, muss ein Pod-Netzwerk-Add-on installiert werden. Calico stellt eine von kubeadm gehostete Installationskonfiguration in Form einer ConfigMap bereit unter http://docs.projectcalico.org/master/getting-started/kubernetes/installation/hosted/kubeadm/calico.yaml, die wir in diesem Abschnitt verwenden werden, um ein Pod-Netzwerk zu installieren. Führen Sie den folgenden Befehl auf dem Master-Knoten aus, um das Pod-Netzwerk zu installieren:

kubectl apply -f
   http://docs.projectcalico.org/master/getting-started/
   kubernetes/installation/hosted/kubeadm/calico.yaml

Laden Sie alternativ die calico.yaml herunter und auf den Master-Knoten kopieren:

scp -i "docker.pem" calico.yaml [email protected]:~

Führen Sie anschließend den folgenden Befehl aus:

kubectl apply -f calico.yaml

Calico und ein etcd-Cluster mit einem einzelnen Knoten werden installiert, wie in Abbildung 8 gezeigt.

Abbildung 8: Calico Policy installieren

Listen Sie anschließend alle Pods in allen Kubernetes-Namespaces auf.

kubectl get pods --all-namespaces

Die kube-dns Der Pod muss ausgeführt werden, wie in Abbildung 9 aufgeführt.

Abbildung 9: Pods in allen Namespaces auflisten

Knoten mit dem Cluster verbinden

In diesem Abschnitt werden wir Worker-Knoten mithilfe von kubeadm join mit dem Cluster verbinden Befehl, der die folgende Syntax hat:

kubeadm join --token=<token> <master-ip>

Optional der kubeadm-Join Der Befehl kann mit --skip-preflight-checks ausgeführt werden Option zum Überspringen der vorläufigen Validierung.

Der kubeadm-Join Der Befehl verwendet das bereitgestellte Token, um mit dem API-Server zu kommunizieren und das Root-CA-Zertifikat abzurufen, und erstellt ein lokales Schlüsselpaar. Anschließend wird eine Certificate Signing Request (CSR) zum Signieren an den API-Server gesendet, und das lokale Kubelet wird so konfiguriert, dass es sich mit dem API-Server verbindet.

Führen Sie den kubeadm-Join aus Befehl, der aus der Ausgabe von kubeadm init kopiert wurde Befehl auf jedem der Ubuntu-Rechner, die dem Cluster beitreten sollen.

Melden Sie sich zuerst mit SSH bei der/den Ubuntu-Instanz(en) an:

ssh -i "docker.pem" [email protected]

und

ssh -i "docker.pem" [email protected]

Führen Sie anschließend den kubeadm join aus Befehl. Zuerst werden einige Vorflugkontrollen durchgeführt. Das bereitgestellte Token wird validiert. Als nächstes wird die Knotenerkennung verwendet. Ein Cluster-Info-Discovery-Client wird erstellt und Informationen werden vom API-Server angefordert. Ein Cluster-Info-Objekt wird empfangen und eine Signatur wird unter Verwendung des angegebenen Tokens verifiziert. Die Cluster-Info-Signatur und -Inhalte werden als gültig befunden und die Knotenerkennung ist abgeschlossen. Anschließend wird ein Node-Bootstrapping durchgeführt, bei dem die API-Endpunkte https://10.0.0.129:6443 zum Verbindungsaufbau verwendet werden. Anschließend wird mithilfe eines API-Clients eine Zertifikatsignierungsanforderung (CSR) gestellt, um ein eindeutiges Zertifikat für den Knoten zu erhalten. Sobald ein signiertes Zertifikat vom API-Server empfangen wird, wird eine Kubelet-Konfigurationsdatei generiert. Die in Abbildung 10 aufgeführte Meldung „Knotenbeitritt abgeschlossen“ zeigt an, dass der Knoten dem Cluster beigetreten ist.

Abbildung 10: Hinzufügen eines Knotens zum Cluster

Führen Sie auf ähnliche Weise denselben Befehl auf dem anderen Ubuntu-Computer aus. Der andere Knoten tritt ebenfalls dem Cluster bei, wie die Ausgabe in Abbildung 11 zeigt.

Abbildung 11: Verbinden des zweiten Knotens mit dem Cluster

Führen Sie auf dem Master-Knoten den folgenden Befehl aus, um die Knoten aufzulisten:

kubectl get nodes

Der Master-Knoten und die beiden Worker-Knoten sollten aufgelistet werden, wie in Abbildung 12 gezeigt.

Abbildung 12: Auflisten von Kubernetes-Clusterknoten

Installieren einer Beispielanwendung

Als nächstes werden wir den Cluster testen. Führen Sie den folgenden Befehl aus, um nginx auszuführen -basierter Pod-Cluster bestehend aus drei Replikaten:

kubectl -s http://localhost:8080 run nginx --image=nginx
   --replicas=3 --port=80

Listen Sie die Bereitstellungen auf:

kubectl get deployments

Clusterweite Pods auflisten:

kubectl get pods -o wide

Stellen Sie die Bereitstellung als Dienst des Typs LoadBalancer bereit :

kubectl expose deployment nginx --port=80 --type=LoadBalancer

Listen Sie die Dienste auf:

kubectl get services

Die Ausgabe der vorherigen Befehle zeigt nginx an Bereitstellung erstellt wurde und die drei Pods auf den beiden Worker-Knoten im Cluster ausgeführt werden. Außerdem wird ein Dienst namens „nginx“ erstellt, wie in Abbildung 13 gezeigt.

Abbildung 13: Ausführen eines Nginx-Pod-Clusters

Kopieren Sie die Cluster-IP des Dienstes. Führen Sie den Curl-Befehl aus, um den Dienst aufzurufen:

curl 10.0.0.99

Das HTML-Markup des Dienstes wird ausgegeben, wie in Abbildung 14 gezeigt.

Abbildung 14: Aufruf des Nginx-Dienstes

Cluster deinstallieren

Um den von kubeadm installierten Cluster zu deinstallieren, führen Sie den folgenden Befehl aus:

kubeadm reset

Der Cluster wird deinstalliert, wie in Abbildung 15 gezeigt.

Abbildung 15: Kubernetes-Cluster deinstallieren/zurücksetzen

Einschränkungen

kubeadm hat mehrere Einschränkungen und wird nur für Entwicklungszwecke empfohlen. Die Einschränkungen von kubeadm sind wie folgt:

Nur wenige Betriebssysteme werden unterstützt:Ubuntu 16.04+, CentOS 7, HypriotOS v1.0.1+.
Nicht für Produktionszwecke geeignet.
Die Integration von Cloud-Anbietern ist experimentell.
Ein Cluster mit nur einem einzigen Master mit einer einzigen etcd-Datenbank darauf wird erstellt. Hochverfügbarkeit wird nicht unterstützt, was bedeutet, dass der Master ein Single Point of Failure (SPOF) ist.
HostPort- und HostIP-Funktionen werden nicht unterstützt.
Einige andere bekannte Probleme, wenn kubeadm mit RHEL/CentOS 7 und VirtualBox verwendet wird.

Weitere Entwicklungen in kubeadm

kubeadm ist in Kubernetes v 1.5 in Alpha und seit Kubernetes 1.6 in Beta. Kleinere Korrekturen und Verbesserungen werden weiterhin mit jeder neuen Kubernetes-Version an kubeadm vorgenommen:

Mit Kubernetes 1.7 werden Änderungen an internen Cluster-Ressourcen, die mit kubeadm installiert wurden, beim Upgrade von Version 1.6 auf Version 1.7 überschrieben.
In Kubernetes 1.8 das standardmäßige Bootstrap-Token, das mit kubeadm init erstellt wurde wird ungültig und wird nach 24 Stunden nach der Erstellung gelöscht, um die Offenlegung der wertvollen Anmeldeinformationen zu begrenzen. Der kubeadm-Join Der Befehl delegiert das TLS-Bootstrapping an das Kubelet selbst, anstatt den Prozess neu zu implementieren. Der Bootstrap KubeConfig Datei wird in /etc/kubernetes/bootstrap-kubelet-conf geschrieben mit kubeadm join .

Schlussfolgerung

In diesem Artikel haben wir die seit Kubernetes v1.4 verfügbare Funktion des kubeadm-Tools verwendet, um einen Kubernetes-Cluster zu booten. Zuerst werden die erforderlichen Binärdateien für Docker, kubectl, kubelet und kubeadm installiert. Anschließend wird die kubeadm init Der Befehl wird verwendet, um den Master-Knoten im Cluster zu initialisieren. Schließlich der kubeadm-Join Der Befehl wird verwendet, um Worker-Knoten mit dem Cluster zu verbinden. Ein Beispiel für nginx Anwendung wird ausgeführt, um den Cluster zu testen.