Dieses Tutorial führt Sie durch die Einrichtung eines Kubernetes-Clusters von Grund auf unter Verwendung von Ansible und Kubeadm und der anschließenden Bereitstellung einer containerisierten Nginx-Anwendung damit.
Einführung
Kubernetes (auch bekannt als k8s oder “kube”) ist eine Open-Source-Plattform zur Container-Orchestrierung, die viele der manuellen Prozesse automatisiert, die bei der Bereitstellung, Verwaltung und Skalierung von containerisierten Anwendungen anfallen. Kubernetes verfügt über eine schnell wachsende Open-Source-Community, die aktiv zum Projekt beiträgt. Werfen Sie einen Blick auf unseren Blog-Beitrag, der Sie in alles einführt, was Sie über die Grundlagen der Kubernetes-Plattform.
Kubeadm ist ein Tool, das verschiedene integrierte Elemente, Teile und Komponenten wie den API-Server, den Controller Manager und Kube DNS konfiguriert. Es hilft auch bei der Automatisierung der Installation. Es erstellt jedoch keine Benutzer, übernimmt nicht die Installation von Abhängigkeiten auf Betriebssystemebene und deren Konfiguration und kann Ihre Infrastruktur nicht bereitstellen.
Ansible ist ein Open-Source-Tool für die Softwarebereitstellung und Anwendungsbereitstellung. Saltstack ist eine Open-Source-Software für die ereignisgesteuerte IT-Automatisierung. Dies sind die beiden Tools, die die Erstellung zusätzlicher Cluster oder die Wiederherstellung bestehender Cluster weniger fehleranfällig machen und für diese vorbereitenden Aufgaben verwendet werden können.
Ziele:
Ihr Cluster wird die folgenden physischen Ressourcen umfassen:
1. Ein Master-Node:
Ein Master-Node ist ein Node, der eine Reihe von Worker-Nodes (Workloads-Laufzeit) steuert und verwaltet und einem Cluster in Kubernetes ähnelt. Er enthält auch den Ressourcenplan des Nodes, um die angemessene Aktion für das ausgelöste Ereignis zu bestimmen. Er führt etcd aus, einen verteilten Open-Source-Schlüssel-Wert-Speicher, der zum Speichern und Verwalten von Clusterdaten unter Komponenten verwendet wird, die Workloads auf Worker-Nodes planen.
Beispielsweise würde der Scheduler ermitteln, welcher Worker-Node einen neu geplanten POD hosten wird.
2. Zwei Worker-Nodes:
Worker-Nodes sind die Nodes, die ihre zugewiesene Arbeit fortsetzen, selbst wenn der Master-Node nach Abschluss der Planung ausfällt. Worker-Nodes sind die Server, auf denen Ihre Workloads (d. h. containerisierte Anwendungen und Dienste) ausgeführt werden. Sie können die Kapazität des Clusters auch durch Hinzufügen von Workern erhöhen.
Sobald Sie dieses Tutorial abgeschlossen haben, verfügen Sie über einen voll funktionsfähigen Cluster, der zur Ausführung von Workloads (d. h. containerisierten Anwendungen und Diensten) bereit ist, vorausgesetzt, die Server im Cluster verfügen über ausreichende CPU- und RAM-Ressourcen für die Ausführung Ihrer Anwendungen. Nachdem Sie den Cluster erfolgreich eingerichtet haben, können Sie fast jede traditionelle UNIX-Anwendung ausführen. Sie kann auf Ihrem Cluster containerisiert werden, einschließlich Webanwendungen, Datenbanken, Daemons und Befehlszeilentools.
Der Cluster selbst verbraucht etwa 300-500 MB Speicher und 10 % CPU auf jedem Node.
Voraussetzungen:
- Sie müssen über ein SSH-Schlüsselpaar auf Ihrem lokalen Linux-Rechner verfügen und wissen, wie man SSH-Schlüssel verwendet. Wenn Sie jedoch noch keine SSH-Schlüssel verwendet haben, kann Ihnen dieses Tutorial helfen, SSH-Schlüssel auf Ihrem lokalen Rechner einzurichten.
- Drei Server mit Ubuntu 18.04 mit jeweils mindestens 4 GB RAM und 4 vCPUs. Sie sollten in der Lage sein, sich als Root-Benutzer mit Ihrem SSH-Schlüsselpaar per SSH auf jedem Server anzumelden. Folgen Sie diesem Tutorial, um Ihren Ubuntu-Server zu installieren.
- Ansible auf Ihrem lokalen Rechner installiert.
- Sie müssen außerdem mit Ansible-Playbooks vertraut sein.
- Sie müssen außerdem wissen, wie Sie einen Container aus einem Docker-Image starten. Sehen Sie sich “Schritt 5 — Arbeiten mit Docker-Images in Ubuntu” in So installieren und verwenden Sie Docker auf Ubuntu 18.04 an, wenn Sie eine Auffrischung benötigen.
Schritt 1 — Einrichten des Workspace-Verzeichnisses und der Ansible-Inventardatei
Sie müssen zuerst Ansible auf Ihrem lokalen Rechner einrichten. Es hilft Ihnen, Befehle auf Ihrem Remote-Server auszuführen. Es erleichtert auch den manuellen Bereitstellungsaufwand durch Automatisierung. Hierzu müssen Sie ein Verzeichnis auf Ihrem lokalen Rechner erstellen, das als Ihr temporärer digitaler Speicherbereich (Workspace) dient.
Sobald Sie ein Verzeichnis erstellt haben, erstellen Sie eine hosts -Datei, um alle Informationen über die IP-Adressen und Gruppen der einzelnen Server zu speichern. Sie hilft Ihnen, die Inventarinformationen darin zu speichern. Wie bereits erwähnt, wird es drei Server geben, einen Master und zwei Worker. Der Master-Server wird der Master sein, dessen IP angezeigt wird als master_ip. Die anderen beiden Server werden Worker sein und die IPs worker_1_ip und worker_2_ip.
Sie müssen ein Verzeichnis namens ~/kube-cluster im Home-Verzeichnis Ihres lokalen Rechners erstellen und mit dem cd-Befehl in dieses Verzeichnis wechseln:
|
1 2 |
mkdir ~/kube-cluster cd ~/kube-cluster |
Das Verzeichnis ~/kube-cluster dient nun als temporärer digitaler Speicherbereich (Workspace), in dem Sie alle lokalen Befehle zur Erstellung eines Kubernetes-Clusters mit kubeadm ausführen. Das Verzeichnis wird alle Ihre Ansible-Playbooks enthalten und für den Rest des Tutorials verwendet.
Erstellen der Hosts-Datei
Erstellen Sie eine Datei namens ~/kube-cluster/hosts mit nano oder Ihrem bevorzugten Texteditor:
|
1 |
nano ~/kube-cluster/hosts |
Nun müssen Sie den folgenden Text hinzufügen, der Informationen über die logische Struktur Ihres Clusters angibt:
|
1 2 3 4 5 6 7 8 9 |
[masters] master ansible_host=master_ip ansible_user=root [workers] worker1 ansible_host=worker_1_ip ansible_user=root worker2 ansible_host=worker_2_ip ansible_user=root [all:vars] ansible_python_interpreter=/usr/bin/python3 |
Wie bereits erwähnt, hilft Ihnen diese Inventardatei dabei, alle Informationen über die IP-Adressen Ihrer Server und die Gruppen, zu denen jeder Server gehört, zu speichern. ~/kube-cluster/hosts wird Ihre Inventardatei sein und (masters und workers) sind die beiden Ansible-Gruppen, die Sie hinzugefügt haben, um die logische Struktur Ihres Clusters zu spezifizieren.
Die Master-Gruppe ist die Gruppe, die festlegt, dass Ansible Remote-Befehle als Root-Benutzer ausführen soll. Sie listet auch die IP des Master-Nodes (master_ip) auf, die durch den Server-Eintrag namens “master” aufgeführt werden kann. Ebenso hat die Gruppe Workers zwei Einträge für die Worker-Server (worker_1_ip und worker_2_ip), die ebenfalls den ansible_user als root angeben.
Die letzte Zeile der Datei weist Ansible an, die Python-3-Interpreter der Remote-Server für seine Verwaltungsoperationen zu verwenden. Schließlich müssen Sie die Datei speichern und schließen, nachdem Sie den Text hinzugefügt haben. Nach dem Einrichten des Workspace-Verzeichnisses und der Ansible-Inventardatei fahren wir mit dem nächsten Schritt fort, der Installation von Abhängigkeiten auf Betriebssystemebene und dem Erstellen von Konfigurationseinstellungen.
Schritt 2 — Erstellen eines Nicht-Root-Benutzers auf allen Remote-Servern
In diesem Schritt lernen Sie, wie Sie einen Nicht-Root-Benutzer mit sudo-Rechten auf allen Servern erstellen, sodass Sie sich manuell als unprivilegierter Benutzer per SSH auf ihnen anmelden können.
Dies kann für häufig durchgeführte Operationen zur Erhaltung eines Clusters nützlich sein. Darüber hinaus hilft Ihnen dieser Schritt, die Aufgabe präziser und weniger fehleranfällig auszuführen, was die Wahrscheinlichkeit verringert, wichtige Dateien unbeabsichtigt zu ändern oder zu löschen. Wenn Sie die Einrichtung von Dateien im Besitz von root ändern oder Systeminformationen mit Befehlen wie top/htop anzeigen und eine Liste der laufenden Container einsehen möchten, hilft Ihnen der folgende Schritt bei der Durchführung all dieser Aufgaben.
Erstellen des Playbooks
Erstellen Sie eine Datei namens ~/kube-cluster/initial.yml im Workspace:
|
1 |
nano ~/kube-cluster/initial.yml |
Als Nächstes müssen Sie das folgende Play hinzufügen. Ein Play in Ansible ist eine Sammlung von auszuführenden Schritten, die auf bestimmte Server und Gruppen abzielen. Ein Playbook kann ein oder mehrere Plays enthalten.
Das folgende Play erstellt einen Nicht-Root-Sudo-Benutzer:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
- hosts: all become: yes tasks: - name: Erstelle den 'ubuntu' Benutzer user: name=ubuntu append=yes state=present createhome=yes shell=/bin/bash - name: Erlaube 'ubuntu' zu haben passwortloses sudo lineinfile: dest: /etc/sudoers line: 'ubuntu ALL=(ALL) NOPASSWD: ALL' validate: 'visudo -cf %s' - name: Richte ein autorisierte Schlüssel für den ubuntu Benutzer authorized_key: user=ubuntu key="{{item}}" with_file: - ~/.ssh/id_rsa.pub |
Im Folgenden finden Sie eine Aufschlüsselung der Funktionen unseres Playbooks:
- Dieses Playbook erstellt den Nicht-Root-Benutzer
ubuntu. - Da Sie
sudo-Befehle ohne Passwortabfrage ausführen müssen, konfiguriert dieses Play diesudoers-Datei, um demubuntu-Benutzer dies zu ermöglichen. - Der Hauptzweck der obigen Aufgabe bestand darin, Ihnen den SSH-Zugriff auf jeden Server als
ubuntu-Benutzer zu ermöglichen. Dieses Playbook fügt den öffentlichen Schlüssel Ihres lokalen Rechners (normalerweise~/.ssh/id_rsa.pub) zur Liste der autorisierten Schlüssel des Remote-ubuntu-Benutzers hinzu.
Nachdem Sie den Text hinzugefügt haben, müssen Sie die Datei speichern und schließen.
Ausführen des Playbooks
Danach müssen wir unser Playbook ausführen, das den Nicht-Root-Benutzer ubuntu erstellt, indem wir es einfach auf lokalen Rechnern ausführen:
|
1 |
ansible-playbook -i hosts ~/kube-cluster/initial.yml |
Die Ausführung dieses Befehls wird einige Zeit in Anspruch nehmen, danach sehen Sie die folgende Ausgabe:
Sobald dieser Schritt abgeschlossen ist, können Sie im nächsten Schritt mit der Installation von Kubernetes-spezifischen Abhängigkeiten fortfahren.
Schritt 3 — Installation der Kubernetes’-Abhängigkeiten
In diesem Schritt erfahren Sie, wie Sie die von Kubernetes benötigten Pakete auf Betriebssystemebene mit dem Paketmanager von Ubuntu installieren.
Diese Pakete sind:
- Docker: Docker ist eine Plattform und ein Tool zum Erstellen, Verteilen und Ausführen von Docker-Containern. Sie können Docker ganz einfach einrichten, indem Sie unserer Anleitung zum Thema wie Sie Docker auf Ubuntu in der Public Cloud installieren & betreiben folgen. Die Unterstützung für andere Runtimes wie rkt befindet sich in Kubernetes jedoch in aktiver Entwicklung.
Kubeadm: kubeadm ist ein CLI-Tool, das die erforderlichen Aktionen ausführt, um ein minimal funktionsfähiges Cluster in Betrieb zu nehmen. Dies hilft Ihnen, verschiedene Komponenten des Clusters auf standardisierte Weise zu installieren und aufzubauen.kubelet: Das kubelet ist der primäre “Node-Agent”, der auf jedem Node läuft und Operationen auf Node-Ebene verarbeitet.kubectl: kubectl ist ebenfalls ein CLI-Tool, das mit Ihrem Cluster kommuniziert und Befehle über dessen API-Server erteilt.
Erstellen des Playbooks
Erstellen Sie eine Datei namens ~/kube-cluster/kube-dependencies.yml im Arbeitsbereich:
|
1 |
nano ~/kube-cluster/kube-dependencies.yml |
Jetzt müssen Sie die folgenden Plays zur Datei hinzufügen, um diese Pakete auf Ihren Servern zu installieren:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
- hosts: all become: yes tasks: - name: Installieren von Docker apt: name: docker.io state: present update_cache: true - name: Installieren von APT Transport HTTPS apt: name: apt-transport-https state: present - name: Hinzufügen von Kubernetes apt-key apt_key: url: https://packages.cloud.google.com/apt/doc/apt-key.gpg validate_certs: false state: present - name: Hinzufügen von Kubernetes' APT-Repository apt_repository: repo: deb http://apt.kubernetes.io/ kubernetes-xenial main state: present filename: 'kubernetes' - name: Installieren von kubelet apt: name: kubelet=1.16.0-00 state: present update_cache: true - name: Installieren von kubeadm apt: name: kubeadm=1.16.0-00 state: present - hosts: master become: yes tasks: - name: Installieren von kubectl apt: name: kubectl=1.16.0-00 state: present force: yes |
Das erste Play im Playbook bewirkt Folgendes:
- Dieses Play hilft Ihnen bei der Installation von Paketen auf Betriebssystemebene, Docker – der Container-Runtime.
- Es installiert
apt-transport-https, was es Ihnen ermöglicht, externe HTTPS-Quellen zu Ihrer APT-Quellenliste hinzuzufügen. - Fügt den apt-key des Kubernetes-APT-Repositorys zur Schlüsselüberprüfung hinzu.
- Fügt das Kubernetes-APT-Repository zur APT-Quellenliste Ihrer Remote-Server hinzu.
- Installiert
kubeletundkubeadm.
Das zweite Play führt eine wichtige und eigenständige Aufgabe aus, die die Installation von kubectl auf Ihrem Master-Node umfasst. Nachdem Sie den Text hinzugefügt haben, müssen Sie die Datei speichern und schließen.
Ausführen des Playbooks
Danach müssen wir unser Playbook ausführen, indem wir es einfach auf lokalen Rechnern starten:
|
1 |
ansible-playbook -i hosts ~/kube-cluster/kube-dependencies.yml |
Die Ausführung dieses Befehls wird einige Zeit in Anspruch nehmen, danach sehen Sie die folgende Ausgabe:
Nach der Ausführung sind Docker, kubeadm und kubelet auf allen Remote-Servern installiert. Kubectl ist keine erforderliche Komponente und wird nur zur Ausführung von Cluster-Befehlen benötigt. Die Installation nur auf dem Master-Node ist in diesem Kontext sinnvoll, da Sie kubectl-Befehle nur vom Master ausführen. Beachten Sie jedoch, dass kubectl Befehle können von jedem der Worker-Nodes oder von jedem Rechner aus ausgeführt werden, auf dem sie installiert und so konfiguriert werden können, dass sie auf einen Cluster verweisen.
Alle Systemabhängigkeiten sind nun installiert. Lassen Sie uns den Master-Node einrichten und den Cluster initialisieren.
Schritt 4 — Einrichten des Master-Nodes
In diesem Schritt lernen Sie einige Konzepte kennen, wie zum Beispiel Pods und Pod-Netzwerk-Plugins, da Ihr Cluster beides enthalten wird, sobald Sie Ihren Master-Node eingerichtet haben.
Pods sind die kleinsten und grundlegendsten bereitstellbaren Objekte in Kubernetes. Pods enthalten einen oder mehrere Container, wie z. B. Docker-Container. Wenn ein Pod mehrere Container ausführt, werden die Container als eine einzige Einheit verwaltet und teilen sich die Ressourcen des Pods.
Jeder Pod hat seine eigene IP-Adresse, und ein Pod auf einem Node sollte in der Lage sein, auf einen Pod auf einem anderen Node über die IP des Pods zuzugreifen. Die Kommunikation zwischen Pods ist jedoch komplexer. Es wird eine separate Komponente benötigt, die den Datenverkehr transparent von einem Pod auf einem Node zu einem Pod auf einem anderen weiterleiten kann. Für diese Funktionalität werden Pod-Netzwerk-Plugins verwendet. Es stehen viele Pod-Netzwerk-Plugins zur Verfügung, aber wir werden Flannel verwenden, da es eine stabile und effiziente Option ist.
Erstellen des Playbooks
Erstellen Sie ein Ansible-Playbook namens master.yml auf Ihrem lokalen Rechner:
|
1 |
nano ~/kube-cluster/master.yml |
Darüber hinaus müssen Sie das folgende Play zur Datei hinzufügen, um den Cluster zu initialisieren und Flannel zu installieren:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
- hosts: master become: yes tasks: - name: initialisieren den Cluster shell: kubeadm init --pod-network-cidr=10.244.0.0/16 >> cluster_initialized.txt args: chdir: $HOME creates: cluster_initialized.txt become: yes become_user: root - name: erstellen .kube-Verzeichnis become: yes become_user: ubuntu file: path: $HOME/.kube state: directory mode: 0755 - name: kopieren admin.conf an Benutzer's kube Konfiguration copy: src: /etc/kubernetes/admin.conf dest: /home/ubuntu/.kube/config remote_src: yes owner: ubuntu - name: installieren Pod-Netzwerk become: yes become_user: ubuntu shell: kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/2140ac876ef134e0ed5af15c65e414cf26827915/Documentation/kube-flannel.yml >> pod_network_setup.txt args: chdir: $HOME creates: pod_network_setup.txt |
Hier’s eine Aufschlüsselung dieses Plays:
- Die erste Aufgabe in diesem Play richtet den Cluster ein, indem sie
kubeadm initausführt. Um das private Subnetz anzugeben, dem die Pod-IPs zugewiesen werden, übergeben wir das Argument--pod-network-cidr=10.244.0.0/16. Flannel verwendet standardmäßig das oben genannte Subnetz. Wir nutzen dies, umkubeadmmitzuteilen, dasselbe Subnetz zu verwenden. - Die zweite Aufgabe dient dem Erstellen eines
.kube-Verzeichnisses unter/home/ubuntu. Konfigurationsinformationen wie die Admin-Schlüsseldateien, die für die Verbindung mit dem Cluster und der API-Adresse des Clusters erforderlich sind, werden in diesem Verzeichnis gespeichert. - Die dritte Aufgabe dient dem Kopieren der Datei
/etc/kubernetes/admin.conf, die durchkubeadm initerzeugt wurde, in das Home-Verzeichnis Ihres Nicht-Root-Benutzers. Dies ermöglicht Ihnen die Verwendung vonkubectl, um auf den neu erstellten Cluster zuzugreifen. - Die letzte Aufgabe führt
kubectl applyaus, umFlannel.kubectl apply -f descriptor.[yml|json]ist die Syntax, umkubectlmitzuteilen, die in der Dateidescriptor.[yml|json]beschriebenen Objekte zu erstellen. Die Dateikube-flannel.ymlenthält die Beschreibungen der Objekte, die für die Einrichtung vonFlannelim Cluster erforderlich sind.
Nachdem Sie den Text hinzugefügt haben, müssen Sie die Datei speichern und schließen.
Ausführen des Playbooks
Danach müssen Sie unser Playbook ausführen, indem Sie auf lokalen Rechnern einfach Folgendes ausführen:
|
1 |
ansible-playbook -i hosts ~/kube-cluster/master.yml |
Die Ausführung dieses Befehls wird einige Zeit in Anspruch nehmen, danach sehen Sie die folgende Ausgabe:
Stellen Sie nun per SSH mit dem folgenden Befehl eine Verbindung her, um den Status des Master-Nodes zu überprüfen:
|
1 |
ssh ubuntu@master_ip |
Sobald Sie sich im Master-Node befinden, führen Sie Folgendes aus:
|
1 |
kubectl get nodes |
Sie sehen nun die folgende Ausgabe:
Sobald Sie die obige Ausgabe erhalten, können Sie davon ausgehen, dass alle Einrichtungsaufgaben vom Master-Node abgeschlossen wurden und dieser bereit ist, Worker-Nodes zu akzeptieren und Aufgaben auszuführen, da er in den Zustand „Ready“ übergeht. Sie können nun die Worker von Ihrem lokalen Rechner aus hinzufügen.
Schritt 5 — Einrichten der Worker-Nodes
Nachdem der Master-Node eingerichtet ist, können wir nun mit dem nächsten Schritt fortfahren, dem Einrichten der Worker-Nodes. Das Hinzufügen von Worker-Nodes zum Cluster kann ganz einfach durch Ausführen eines einzigen Befehls auf jedem Worker-Server erfolgen. Wichtige Informationen wie die IP-Adresse, der Port des API-Servers des Masters und ein sicheres Token sind in diesem Befehl enthalten. Beachten Sie jedoch, dass nicht alle Nodes dem Cluster beitreten können, sondern nur diejenigen, die das sichere Token übergeben.
Erstellen des Playbooks
Dieser Befehl hilft Ihnen, zurück zu Ihrem Arbeitsbereich zu navigieren und ein Playbook namens workers.yml:
|
1 |
nano ~/kube-cluster/workers.yml |
Fügen Sie der Datei den folgenden Text hinzu, um die Worker zum Cluster hinzuzufügen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
- hosts: master become: yes gather_facts: false tasks: - name: get join command shell: kubeadm token create --print-join-command register: join_command_raw - name: set join command set_fact: join_command: "{{ join_command_raw.stdout_lines[0] }}" - hosts: workers become: yes tasks: - name: join cluster shell: "{{ hostvars['master'].join_command }} >> node_joined.txt" args: chdir: $HOME creates: node_joined.txt |
Das bewirkt das Playbook. Der obige Code enthält zwei Plays:
- Das erste Play wird verwendet, um den Beitrittsbefehl abzurufen, der auf den Worker-Nodes ausgeführt werden muss. Das Format des Befehls lautet:
kubeadm join --token sha256:<hash><token><master-ip>:<master-port> --discovery-token-ca-cert-hash sha256:<hash>;. Der Task muss die korrekten Token- und Hash-Werte abrufen. Sobald er die korrekte Eingabe erhält, legt der Task diese als Fact fest, sodass das zweite Play auf diese Informationen zugreifen kann. - Das zweite Play ist nur für eine einzige Aufgabe geschrieben – die beiden Worker-Nodes zu einem Teil des Clusters zu machen, indem einfach der Beitrittsbefehl auf allen Worker-Nodes ausgeführt wird.
Nach dem Hinzufügen des Textes müssen Sie die Datei speichern und schließen.
Ausführen des Playbooks
Danach müssen wir unser Playbook ausführen, indem wir den folgenden Befehl auf den Worker-Maschinen ausführen:
|
1 |
ansible-playbook -i hosts ~/kube-cluster/workers.yml |
Die Ausführung dieses Befehls wird einige Zeit in Anspruch nehmen, danach sehen Sie die folgende Ausgabe:
Jetzt ist Ihr Kubernetes-Cluster vollständig eingerichtet und funktionsfähig, und die Worker sind bereit, Workloads auszuführen. Bevor wir zum nächsten Schritt übergehen, überprüfen wir, ob der Cluster wie geplant funktioniert.
Schritt 6 — Überprüfen des Clusters
Es kann vorkommen, dass ein Cluster während der Einrichtung fehlschlägt. Dies kann an einem Netzwerkfehler zwischen Master und Worker oder an einem Node-Problem liegen. Daher müssen wir den Cluster überprüfen, bevor wir Anwendungen planen, und sicherstellen, dass keine Fehlfunktionen auftreten. Dazu müssen Sie den aktuellen Zustand des Clusters vom Master-Node aus überprüfen, um sicherzustellen, dass die Nodes bereit sind. Sie können die Verbindung mit dem folgenden Befehl wiederherstellen, wenn die Nodes nicht bereit sind oder die Verbindung getrennt wurde:
|
1 |
ssh ubuntu@master_ip |
Verwenden Sie die folgenden Befehle, um den Status des Clusters abzurufen:
|
1 |
kubectl get nodes |
Die Ausführung dieses Befehls wird einige Zeit in Anspruch nehmen, danach sehen Sie die folgende Ausgabe:
Sie müssen überprüfen, ob sich alle Nodes, die Teil des Clusters sind, im Zustand „Ready“ befinden. Wenn einige Nodes Not Ready als STATUS haben, zeigt dies, dass die Worker-Nodes ihre Einrichtung noch nicht abgeschlossen haben. Bevor Sie jedoch kubectl get nodes erneut ausführen und die aktualisierte Ausgabe überprüfen, sollten Sie weitere fünf bis zehn Minuten warten. Wenn einige der Nodes immer noch Not Ready als Status anzeigen, sollten Sie die vorherigen Schritte überprüfen und die Befehle erneut ausführen. Nur wenn die Nodes den Wert „Ready“ für STATUS haben, sind sie Teil des Clusters und bereit, Workloads auszuführen. Nach erfolgreicher Ausführung des 6. Schritts ist Ihr Cluster nun verifiziert. Lassen Sie uns nun eine Beispiel-Nginx-Anwendung auf dem Cluster planen.
Schritt 7 — Ausführen einer Anwendung auf dem Cluster
Deployment erstellen
Nachdem Sie den Cluster erfolgreich erstellt haben, können Sie jede containerisierte Anwendung auf Ihrem Cluster bereitstellen. Sie können die folgenden Befehle unten für andere containerisierte Anwendungen verwenden, wenn Sie sich auf dem Master-Node befinden. Führen Sie als Nächstes den folgenden Befehl aus, um ein Deployment namens nginx :
|
1 |
kubectl create deployment nginx --image=nginx |
Sie müssen den Namen des Docker-Images und alle relevanten Flags (wie Ports und Volumes) ändern. Um die Dinge vertraut zu halten, können Sie Nginx mithilfe von Deployments und Services bereitstellen, um zu sehen, wie Anwendungen auf dem Cluster bereitgestellt werden können.
Ein Kubernetes-Deployment ist ein Ressourcenobjekt in Kubernetes, das deklarative Aktualisierungen für Anwendungen bereitstellt. Ein Deployment ermöglicht es Ihnen, den Lebenszyklus einer Anwendung zu beschreiben, wie z. B. Container-Image, Replikate und die Aktualisierungsstrategie. Ein Deployment stellt sicher, dass die gewünschte Anzahl von Pods jederzeit ausgeführt wird und verfügbar ist. Wenn ein Pod während der Lebensdauer des Clusters abstürzt, wird er erneut gestartet. Der Aktualisierungsprozess wird ebenfalls vollständig aufgezeichnet und versioniert, mit Optionen zum Pausieren, Fortsetzen und Zurückrollen auf vorherige Versionen. Der obige Befehl zum Erstellen eines Deployments namens Nginx hilft Ihnen, einen Pod mit einem Container aus dem Nginx-Docker-Image der Docker-Registry bereitzustellen.
NodePort einrichten
Als Nächstes müssen wir ein NodePort. NodePort ist ein offener Port auf jedem Knoten Ihres Clusters. Kubernetes leitet eingehenden Datenverkehr auf dem NodePort transparent an Ihren Dienst weiter, selbst wenn Ihre Anwendung auf einem anderen Knoten ausgeführt wird. Hierfür können wir diesen Befehl verwenden, um eine NodePort-Ressource namens Nginx zu erstellen, die die App öffentlich zugänglich macht:
|
1 |
kubectl expose deploy nginx --port 80 --target-port 80 --type NodePort |
Ein Service ist ein weiteres Kubernetes-Objekt, das für das Bereitstellen einer Schnittstelle zu diesen Pods verantwortlich ist, was den Netzwerkzugriff entweder von innerhalb des Clusters oder zwischen externen Prozessen und dem Service ermöglicht. Er kann als eine Abstraktion über dem Pod definiert werden, die eine einzige IP-Adresse und einen DNS-Namen bereitstellt, über die auf Pods zugegriffen werden kann. Mit einem Service ist es sehr einfach, die Lastverteilungskonfiguration zu verwalten.
Führen Sie den folgenden Befehl aus:
|
1 |
kubectl get services |
Dies führt zu einer Ausgabe ähnlich der folgenden:
Nach Erhalt der Ausgabe weist Kubernetes automatisch einen zufälligen Port zu, der größer ist als 30000, während gleichzeitig sichergestellt wird, dass der zugewiesene Port nicht bereits von einem anderen Dienst belegt ist. Die dritte Zeile der obigen Ausgabe hilft Ihnen, den Port zu ermitteln, auf dem Nginx ausgeführt wird.
Um zu überprüfen, ob es funktioniert, rufen Sie http://worker_1_ip:nginx_port oder http://worker_2_ip:nginx_port über einen Browser auf Ihrem lokalen Rechner auf. Sie sehen die bekannte Willkommensseite von Nginx.
Deployment entfernen
Wenn Sie die Nginx-Anwendung entfernen möchten, müssen Sie zuerst den nginx-Dienst vom Master-Knoten löschen:
|
1 |
kubectl delete service nginx |
Um zu überprüfen, ob die Anwendung endgültig gelöscht wurde, müssen Sie diesen Befehl ausführen:
|
1 |
kubectl get services |
Sie erhalten die folgende Ausgabe:
Danach müssen Sie das Deployment mit dem folgenden Befehl löschen:
|
1 |
kubectl delete deployment nginx |
Sie können diesen Befehl verwenden, um zu überprüfen, ob das Deployment endgültig gelöscht wurde:
|
1 |
kubectl get deployments |
Fazit:
Dieses Tutorial hilft Ihnen dabei, einen Cluster auf Ubuntu 18.04 mit Kubeadm und Ansible ordnungsgemäß einzurichten. Da Ihr Cluster nun eingerichtet ist, können Sie ganz einfach mit der Bereitstellung Ihrer eigenen Anwendungen und Dienste beginnen.
Hier ist eine Liste von Links mit zusätzlichen Details, die Sie durch den Prozess führen:
- Anwendungen dockerisieren – Dieser Link enthält Beispiele, die Ihnen zeigen, wie Sie Anwendungen mit Docker laden. Wie z. B. das Dockerisieren von PostgreSQL, einem CouchDB-Dienst usw.
- Pod-Übersicht – Dieser Link zeigt Details zur Verwendung eines Pods, zur Funktionsweise von Pods und wie Pods mit anderen Kubernetes-Objekten zusammenhängen. Pods sind ein wichtiger Bestandteil von Kubernetes, daher wird Ihnen das Verständnis dieser Konzepte helfen, Ihre Aufgabe erfolgreich zu meistern.
- Deployments-Übersicht – Hier erfahren Sie mehr über Deployments. Ein Deployment bietet deklarative Aktualisierungen für Pods und ReplicaSets. Sie lernen, wie Sie ein Deployment aktualisieren, fortlaufend aktualisieren und zurückrollen.
- Services-Übersicht - Dieser Link führt Sie in Services ein, ein weiteres häufig verwendetes Objekt in Kubernetes-Clustern. Ein Service in Kubernetes ist eine Abstraktion, die eine logische Gruppe von Pods und eine Richtlinie für den Zugriff darauf definiert. Das Verständnis der verschiedenen Service-Typen und ihrer Optionen ist für den Betrieb sowohl zustandsloser als auch zustandsbehafteter Anwendungen unerlässlich.
Werfen Sie außerdem einen Blick auf unsere anderen Tutorials zu Docker und Kubernetes, die Sie auf unserem Blog:
- Kubernetes kennenlernen
- Docker-Ressourcen bereinigen – Images, Container und Volumes
- Wie Sie Docker auf CloudSigma ausführen (mit CloudInit) Aktualisiert
- Installation und Einrichtung von Docker auf CentOS 7
- Wie Sie Docker auf Ubuntu in der Public Cloud installieren & betreiben
Es gibt auch viele andere wichtige Konzepte wie Volumes, Ingresses, und Secrets die Sie bei der Bereitstellung von Produktionsanwendungen verwenden können.
Viel Spaß beim Computing!
Kommentare
Noch keine Kommentare. Schreiben Sie den ersten.