TOC

So erstellen Sie einen Kubernetes-Cluster mit Kubeadm unter Ubuntu 18.04

Der Autor hat den Free and Open Source Fund ausgewählt, um eine Spende als Teil des Write for DOnations zu erhalten. Programm.

Einführung

https://kubernetes.io [Kubernetes] ist ein Container-Orchestrierungssystem, das Container in großem Maßstab verwaltet. Kubernetes wurde ursprünglich von Google auf der Grundlage seiner Erfahrung mit der Ausführung von Containern in der Produktion entwickelt. Es ist Open Source und wird von einer Community auf der ganzen Welt aktiv entwickelt.

Kubeadm automatisiert die Installation und Konfiguration von Kubernetes-Komponenten wie API-Server, Controller Manager und Kube DNS. Es werden jedoch keine Benutzer erstellt oder die Installation von Abhängigkeiten auf Betriebssystemebene und deren Konfiguration verwaltet. Für diese vorbereitenden Aufgaben kann ein Konfigurationsverwaltungstool wie Ansible oder SaltStack verwendet werden. Die Verwendung dieser Tools vereinfacht die Erstellung zusätzlicher Cluster oder die Neuerstellung vorhandener Cluster erheblich und ist weniger fehleranfällig.

In diesem Handbuch richten Sie mit Ansible und Kubeadm einen Kubernetes-Cluster von Grund auf neu ein und stellen darauf eine containerisierte Nginx-Anwendung bereit.

Tore

Ihr Cluster enthält die folgenden physischen Ressourcen:

  • * Ein Masterknoten *

Der Masterknoten (ein Node in Kubernetes bezieht sich auf einen Server) ist für die Verwaltung des Clusterstatus verantwortlich. Es wird Etcd ausgeführt, in dem Clusterdaten zwischen Komponenten gespeichert werden, die Workloads für Worker-Knoten planen.

  • * Zwei Arbeitsknoten *

Arbeitsknoten sind die Server, auf denen Ihre Workloads (d. H. containerisierte Anwendungen und Dienste) werden ausgeführt. Ein Worker führt Ihre Workload weiter aus, sobald er ihr zugewiesen wurde, auch wenn der Master nach Abschluss der Planung ausfällt. Die Kapazität eines Clusters kann durch Hinzufügen von Mitarbeitern erhöht werden.

Nachdem Sie dieses Handbuch ausgefüllt haben, steht ein Cluster zur Ausführung von Anwendungen mit Container zur Verfügung, vorausgesetzt, die Server im Cluster verfügen über ausreichende CPU- und RAM-Ressourcen, die Ihre Anwendungen nutzen können. Nahezu jede herkömmliche Unix-Anwendung, einschließlich Webanwendungen, Datenbanken, Daemons und Befehlszeilentools, kann containerisiert und für die Ausführung auf dem Cluster konfiguriert werden. Der Cluster selbst belegt auf jedem Knoten ca. 300-500 MB Arbeitsspeicher und 10% der CPU.

Sobald der Cluster eingerichtet ist, stellen Sie den Webserver Nginx für ihn bereit, um sicherzustellen, dass die Workloads ordnungsgemäß ausgeführt werden.

Voraussetzungen

Schritt 1 - Einrichten des Arbeitsbereichsverzeichnisses und der Ansible-Inventardatei

In diesem Abschnitt erstellen Sie ein Verzeichnis auf Ihrem lokalen Computer, das als Arbeitsbereich dient. Sie konfigurieren Ansible lokal, damit es mit Ihren Remote-Servern kommunizieren und Befehle ausführen kann. Anschließend erstellen Sie eine "+ hosts +" - Datei mit Inventarinformationen wie den IP-Adressen Ihrer Server und den Gruppen, zu denen die einzelnen Server gehören.

Von Ihren drei Servern ist einer der Master mit einer IP, die als "" angezeigt wird. Die anderen beiden Server sind Worker und haben die IPs "" und "++".

Erstellen Sie ein Verzeichnis mit dem Namen "+ ~ / kube-cluster " im Home-Verzeichnis Ihres lokalen Computers und geben Sie " cd +" ein:

mkdir ~/kube-cluster
cd ~/kube-cluster

Dieses Verzeichnis ist Ihr Arbeitsbereich für den Rest des Tutorials und enthält alle Ihre Ansible-Playbooks. Dies ist auch das Verzeichnis, in dem Sie alle lokalen Befehle ausführen.

Erstellen Sie eine Datei mit dem Namen "+ ~ / kube-cluster / hosts " mit " nano +" oder Ihrem bevorzugten Texteditor:

nano ~/kube-cluster/hosts

Fügen Sie der Datei den folgenden Text hinzu, der Informationen zur logischen Struktur Ihres Clusters enthält:

~ / kube-cluster / hosts

[masters]
master ansible_host= ansible_user=root

[workers]
worker1 ansible_host= ansible_user=root
worker2 ansible_host= ansible_user=root

[all:vars]
ansible_python_interpreter=/usr/bin/python3

Möglicherweise erinnern Sie sich, dass inventory files in Ansible verwendet wird, um Serverinformationen wie IP-Adressen, Remotebenutzer und Gruppierungen von Servern anzugeben, auf die abgezielt werden soll eine einzelne Einheit zum Ausführen von Befehlen. "+ ~ / kube-cluster / hosts +" ist Ihre Inventardatei, und Sie haben zwei Ansible-Gruppen (* master * und * worker *) hinzugefügt, die die logische Struktur Ihres Clusters angeben.

In der Gruppe * masters * gibt es einen Servereintrag mit dem Namen "master", der die IP des Masterknotens ("++") auflistet und angibt, dass Ansible als Root-Benutzer Remotebefehle ausführen soll.

Ebenso gibt es in der Gruppe * workers * zwei Einträge für die Arbeitsserver (` und `), die auch den + ansible_user + als root angeben.

In der letzten Zeile der Datei wird Ansible angewiesen, die Python 3-Interpreter der Remoteserver für die Verwaltungsvorgänge zu verwenden.

Speichern und schließen Sie die Datei, nachdem Sie den Text hinzugefügt haben.

Nachdem Sie die Serverbestandsliste mit Gruppen eingerichtet haben, fahren Sie mit der Installation von Abhängigkeiten auf Betriebssystemebene und dem Erstellen von Konfigurationseinstellungen fort.

Schritt 2 - Erstellen eines Nicht-Root-Benutzers auf allen Remote-Servern

In diesem Abschnitt erstellen Sie auf allen Servern einen Nicht-Root-Benutzer mit sudo-Berechtigungen, damit Sie als nichtprivilegierter Benutzer manuell SSH-Zugriff auf diese Server haben. Dies kann nützlich sein, wenn Sie beispielsweise Systeminformationen mit Befehlen wie "+ top / htop +" anzeigen, eine Liste der ausgeführten Container anzeigen oder Konfigurationsdateien ändern möchten, deren Eigentümer root ist. Diese Vorgänge werden routinemäßig während der Wartung eines Clusters ausgeführt. Die Verwendung eines Nicht-Root-Benutzers für solche Aufgaben minimiert das Risiko, wichtige Dateien zu ändern oder zu löschen oder andere gefährliche Vorgänge ungewollt auszuführen.

Erstellen Sie eine Datei mit dem Namen "+ ~ / kube-cluster / initial.yml +" im Arbeitsbereich:

nano ~/kube-cluster/initial.yml

Fügen Sie anschließend der Datei das folgende play hinzu, um einen Benutzer ohne Rootberechtigung mit sudo-Berechtigungen auf allen Servern zu erstellen. Ein Stück in Ansible ist eine Sammlung von Schritten, die für bestimmte Server und Gruppen ausgeführt werden müssen. Das folgende Spiel erstellt einen Benutzer ohne Rootberechtigung:

~ / kube-cluster / initial.yml

- hosts: all
 become: yes
 tasks:
   - name: create the 'ubuntu' user
     user: name=ubuntu append=yes state=present createhome=yes shell=/bin/bash

   - name: allow 'ubuntu' to have passwordless sudo
     lineinfile:
       dest: /etc/sudoers
       line: 'ubuntu ALL=(ALL) NOPASSWD: ALL'
       validate: 'visudo -cf %s'

   - name: set up authorized keys for the ubuntu user
     authorized_key: user=ubuntu key="{{item}}"
     with_file:
       - ~/.ssh/id_rsa.pub

Im Folgenden finden Sie eine Aufschlüsselung der Funktionen dieses Wiedergabebuchs:

  • Erstellt den Nicht-Root-Benutzer "+ ubuntu".

  • Konfiguriert die Datei "+ sudoers" so, dass der Benutzer "+ ubuntu" "+ sudo +" - Befehle ohne Kennworteingabeaufforderung ausführen kann.

  • Fügt den öffentlichen Schlüssel in Ihrem lokalen Computer (normalerweise "+ ~ / .ssh / id_rsa.pub ") zur Liste der autorisierten Schlüssel des fernen " ubuntu " Benutzers hinzu. Auf diese Weise können Sie als " ubuntu +" - Benutzer auf jedem Server SSH ausführen.

Speichern und schließen Sie die Datei, nachdem Sie den Text hinzugefügt haben.

Führen Sie als Nächstes das Playbook aus, indem Sie Folgendes lokal ausführen:

ansible-playbook -i hosts ~/kube-cluster/initial.yml

Der Befehl wird innerhalb von zwei bis fünf Minuten ausgeführt. Nach Abschluss wird eine Ausgabe ähnlich der folgenden angezeigt:

OutputPLAY [all] ****

TASK [Gathering Facts] ****
ok: [master]
ok: [worker1]
ok: [worker2]

TASK [create the 'ubuntu' user] ****
changed: [master]
changed: [worker1]
changed: [worker2]

TASK [allow 'ubuntu' user to have passwordless sudo] ****
changed: [master]
changed: [worker1]
changed: [worker2]

TASK [set up authorized keys for the ubuntu user] ****
changed: [worker1] => (item=ssh-rsa AAAAB3...)
changed: [worker2] => (item=ssh-rsa AAAAB3...)
changed: [master] => (item=ssh-rsa AAAAB3...)

PLAY RECAP ****
master                     : ok=5    changed=4    unreachable=0    failed=0
worker1                    : ok=5    changed=4    unreachable=0    failed=0
worker2                    : ok=5    changed=4    unreachable=0    failed=0

Nachdem die vorbereitenden Einstellungen abgeschlossen sind, können Sie mit der Installation von Kubernetes-spezifischen Abhängigkeiten fortfahren.

Schritt 3 - Installieren der Kubernetes-Abhängigkeiten

In diesem Abschnitt installieren Sie die Pakete auf Betriebssystemebene, die Kubernetes mit dem Paket-Manager von Ubuntu benötigt. Diese Pakete sind:

  • Docker - eine Container-Laufzeit. Es ist die Komponente, die Ihre Container ausführt. Die Unterstützung anderer Laufzeiten wie rkt wird derzeit in Kubernetes entwickelt.

  • + kubeadm + - ein CLI-Tool, mit dem die verschiedenen Komponenten eines Clusters auf standardmäßige Weise installiert und konfiguriert werden.

  • + kubelet + - Ein Systemdienst / -programm, das auf allen Knoten ausgeführt wird und Operationen auf Knotenebene ausführt.

  • + kubectl + - Ein CLI-Tool, mit dem Befehle über seinen API-Server an den Cluster ausgegeben werden.

Erstellen Sie eine Datei mit dem Namen "+ ~ / kube-cluster / kube-dependencies.yml +" im Arbeitsbereich:

nano ~/kube-cluster/kube-dependencies.yml

Fügen Sie der Datei die folgenden Wiedergaben hinzu, um diese Pakete auf Ihren Servern zu installieren:

~ / kube-cluster / kube-dependencies.yml

- hosts: all
 become: yes
 tasks:
  - name: install Docker
    apt:
      name: docker.io
      state: present
      update_cache: true

  - name: install APT Transport HTTPS
    apt:
      name: apt-transport-https
      state: present

  - name: add Kubernetes apt-key
    apt_key:
      url: https://packages.cloud.google.com/apt/doc/apt-key.gpg
      state: present

  - name: add Kubernetes' APT repository
    apt_repository:
     repo: deb http://apt.kubernetes.io/ kubernetes-xenial main
     state: present
     filename: 'kubernetes'

  - name: install kubelet
    apt:
      name: kubelet=1.14.0-00
      state: present
      update_cache: true

  - name: install kubeadm
    apt:
      name: kubeadm=1.14.0-00
      state: present

- hosts: master
 become: yes
 tasks:
  - name: install kubectl
    apt:
      name: kubectl=1.14.0-00
      state: present
      force: yes

Das erste Spiel im Spielbuch führt Folgendes aus:

  • Installiert Docker, die Container-Laufzeit.

  • Installieren Sie "+ apt-transport-https", damit Sie externe HTTPS-Quellen zu Ihrer APT-Quellenliste hinzufügen können.

  • Fügt den passenden Schlüssel des Kubernetes APT-Repositorys zur Schlüsselüberprüfung hinzu.

  • Fügt das Kubernetes APT-Repository der APT-Quellenliste Ihres Remote-Servers hinzu.

  • Installieren Sie + kubelet und` + kubeadm`.

Das zweite Spiel besteht aus einer einzelnen Aufgabe, die "+ kubectl" auf Ihrem Masterknoten installiert.

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Führen Sie als Nächstes das Playbook aus, indem Sie Folgendes lokal ausführen:

ansible-playbook -i hosts ~/kube-cluster/kube-dependencies.yml

Nach Abschluss wird eine Ausgabe ähnlich der folgenden angezeigt:

OutputPLAY [all] ****

TASK [Gathering Facts] ****
ok: [worker1]
ok: [worker2]
ok: [master]

TASK [install Docker] ****
changed: [master]
changed: [worker1]
changed: [worker2]

TASK [install APT Transport HTTPS] *****
ok: [master]
ok: [worker1]
changed: [worker2]

TASK [add Kubernetes apt-key] *****
changed: [master]
changed: [worker1]
changed: [worker2]

TASK [add Kubernetes' APT repository] *****
changed: [master]
changed: [worker1]
changed: [worker2]

TASK [install kubelet] *****
changed: [master]
changed: [worker1]
changed: [worker2]

TASK [install kubeadm] *****
changed: [master]
changed: [worker1]
changed: [worker2]

PLAY [master] *****

TASK [Gathering Facts] *****
ok: [master]

TASK [install kubectl] ******
ok: [master]

PLAY RECAP ****
master                     : ok=9    changed=5    unreachable=0    failed=0
worker1                    : ok=7    changed=5    unreachable=0    failed=0
worker2                    : ok=7    changed=5    unreachable=0    failed=0

Nach der Ausführung werden Docker, "+ kubeadm " und " kubelet " auf allen Remote-Servern installiert. ` kubectl ` ist keine erforderliche Komponente und wird nur zum Ausführen von Cluster-Befehlen benötigt. Die Installation nur auf dem Master-Knoten ist in diesem Zusammenhang sinnvoll, da Sie die Befehle ` kubectl ` nur vom Master aus ausführen. Beachten Sie jedoch, dass " kubectl +" - Befehle von jedem der Worker-Knoten oder von jedem Computer ausgeführt werden können, auf dem es so installiert und konfiguriert werden kann, dass es auf einen Cluster verweist.

Alle Systemabhängigkeiten sind jetzt installiert. Richten wir den Master-Knoten ein und initialisieren den Cluster.

Schritt 4 - Einrichten des Master-Knotens

In diesem Abschnitt richten Sie den Masterknoten ein. Bevor Sie jedoch ein Playbook erstellen, sollten Sie einige Konzepte wie Pods und Pod Network Plugins behandeln, da Ihr Cluster beides enthält.

Ein Pod ist eine atomare Einheit, die einen oder mehrere Container ausführt. Diese Container nutzen Ressourcen wie Dateivolumes und Netzwerkschnittstellen gemeinsam. Pods sind die Grundeinheit für die Planung in Kubernetes: Alle Container in einem Pod werden garantiert auf demselben Knoten ausgeführt, auf dem der Pod geplant ist.

Jeder Pod hat eine eigene IP-Adresse, und ein Pod auf einem Knoten sollte unter Verwendung der IP-Adresse des Pods auf einen Pod auf einem anderen Knoten zugreifen können. Container auf einem einzelnen Knoten können problemlos über eine lokale Schnittstelle kommunizieren. Die Kommunikation zwischen Pods ist jedoch komplizierter und erfordert eine separate Netzwerkkomponente, die den Datenverkehr transparent von einem Pod auf einem Knoten zu einem Pod auf einem anderen weiterleiten kann.

Diese Funktionalität wird durch Pod-Netzwerk-Plugins bereitgestellt. Für diesen Cluster verwenden Sie Flannel, eine stabile und performante Option.

Erstellen Sie ein Ansible-Playbook mit dem Namen "+ master.yml +" auf Ihrem lokalen Computer:

nano ~/kube-cluster/master.yml

Fügen Sie der Datei die folgende Wiedergabe hinzu, um den Cluster zu initialisieren und Flannel zu installieren:

~ / kube-cluster / master.yml

- hosts: master
 become: yes
 tasks:
   - name: initialize the cluster
     shell: kubeadm init --pod-network-cidr=10.244.0.0/16 >> cluster_initialized.txt
     args:
       chdir: $HOME
       creates: cluster_initialized.txt

   - name: create .kube directory
     become: yes
     become_user: ubuntu
     file:
       path: $HOME/.kube
       state: directory
       mode: 0755

   - name: copy admin.conf to user's kube config
     copy:
       src: /etc/kubernetes/admin.conf
       dest: /home/ubuntu/.kube/config
       remote_src: yes
       owner: ubuntu

   - name: install Pod network
     become: yes
     become_user: ubuntu
     shell: kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml >> pod_network_setup.txt
     args:
       chdir: $HOME
       creates: pod_network_setup.txt

Hier ist eine Aufschlüsselung dieses Stücks:

  • Die erste Task initialisiert den Cluster durch Ausführen von + kubeadm init +. Das Übergeben des Arguments "+ - pod-network-cidr = 10.244.0.0 / 16 " gibt das private Subnetz an, von dem aus die Pod-IPs zugewiesen werden. Flannel verwendet standardmäßig das oben genannte Subnetz. Wir sagen " kubeadm +", dass dasselbe Subnetz verwendet werden soll.

  • Die zweite Aufgabe erstellt ein "+ .kube" -Verzeichnis unter "+ / home / ubuntu". Dieses Verzeichnis enthält Konfigurationsinformationen wie die Administrator-Schlüsseldateien, die für die Verbindung zum Cluster erforderlich sind, und die API-Adresse des Clusters.

  • Die dritte Aufgabe kopiert die Datei "+ / etc / kubernetes / admin.conf ", die aus " kubeadm init " generiert wurde, in das Ausgangsverzeichnis Ihres Nicht-Root-Benutzers. Auf diese Weise können Sie mit ` kubectl +` auf den neu erstellten Cluster zugreifen.

  • Die letzte Aufgabe führt "+ kubectl apply " aus, um " Flannel " zu installieren. ` kubectl apply -f descriptor. [yml | json] ` ist die Syntax, mit der ` kubectl ` angewiesen wird, die in der Datei ` descriptor. [yml | json] ` beschriebenen Objekte zu erstellen. Die Datei " kube-flannel.yml " enthält die Beschreibungen der Objekte, die zum Einrichten von " Flannel +" im Cluster erforderlich sind.

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Führen Sie das Playbook lokal aus, indem Sie Folgendes ausführen:

ansible-playbook -i hosts ~/kube-cluster/master.yml

Nach Abschluss wird eine Ausgabe ähnlich der folgenden angezeigt:

Output
PLAY [master] ****

TASK [Gathering Facts] ****
ok: [master]

TASK [initialize the cluster] ****
changed: [master]

TASK [create .kube directory] ****
changed: [master]

TASK [copy admin.conf to user's kube config] *****
changed: [master]

TASK [install Pod network] *****
changed: [master]

PLAY RECAP ****
master                     : ok=5    changed=4    unreachable=0    failed=0

Um den Status des Master-Knotens zu überprüfen, rufen Sie ihn mit SSH mit dem folgenden Befehl auf:

ssh ubuntu@

Führen Sie im Masterknoten Folgendes aus:

kubectl get nodes

Sie sehen nun folgende Ausgabe:

OutputNAME      STATUS    ROLES     AGE       VERSION
master    Ready     master    1d        v1.14.0

Die Ausgabe besagt, dass der "+ Master " - Knoten alle Initialisierungsaufgaben abgeschlossen hat und sich in einem " Ready +" - Status befindet, von dem aus er Arbeitsknoten akzeptieren und an den API-Server gesendete Aufgaben ausführen kann. Sie können jetzt die Worker von Ihrem lokalen Computer hinzufügen.

Schritt 5 - Einrichten der Arbeitsknoten

Zum Hinzufügen von Workern zum Cluster muss jeweils ein Befehl ausgeführt werden. Dieser Befehl enthält die erforderlichen Clusterinformationen, z. B. die IP-Adresse und den Port des Master-API-Servers sowie ein sicheres Token. Nur Knoten, die das sichere Token übergeben, können dem Cluster beitreten.

Navigieren Sie zurück zu Ihrem Arbeitsbereich und erstellen Sie ein Playbook mit dem Namen "+ workers.yml +":

nano ~/kube-cluster/workers.yml

Fügen Sie der Datei den folgenden Text hinzu, um die Worker zum Cluster hinzuzufügen:

~ / kube-cluster / workers.yml

- 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 Playbook bietet folgende Funktionen:

  • Bei der ersten Wiedergabe wird der Join-Befehl abgerufen, der auf den Arbeitsknoten ausgeführt werden muss. Dieser Befehl hat das folgende Format: + kubeadm join --token <Token> <Master-IP>: <Master-Port> --Discovery-Token-Ca-Cert-Hash sha256: <Hash> +. Sobald es den tatsächlichen Befehl mit den richtigen * Token * - und * Hash * -Werten erhält, setzt die Task ihn als Fakt, sodass das nächste Spiel auf diese Informationen zugreifen kann.

  • Das zweite Spiel hat eine einzelne Aufgabe, die den Join-Befehl auf allen Worker-Knoten ausführt. Nach Abschluss dieser Aufgabe sind die beiden Arbeitsknoten Teil des Clusters.

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Führen Sie das Playbook aus, indem Sie Folgendes lokal ausführen:

ansible-playbook -i hosts ~/kube-cluster/workers.yml

Nach Abschluss wird eine Ausgabe ähnlich der folgenden angezeigt:

OutputPLAY [master] ****

TASK [get join command] ****
changed: [master]

TASK [set join command] *****
ok: [master]

PLAY [workers] *****

TASK [Gathering Facts] *****
ok: [worker1]
ok: [worker2]

TASK [join cluster] *****
changed: [worker1]
changed: [worker2]

PLAY RECAP *****
master                     : ok=2    changed=1    unreachable=0    failed=0
worker1                    : ok=2    changed=1    unreachable=0    failed=0
worker2                    : ok=2    changed=1    unreachable=0    failed=0

Mit dem Hinzufügen der Worker-Knoten ist Ihr Cluster nun vollständig eingerichtet und funktionsfähig, und die Worker können Workloads ausführen. Vergewissern Sie sich vor dem Planen von Anwendungen, dass der Cluster ordnungsgemäß funktioniert.

Schritt 6 - Überprüfen des Clusters

Ein Cluster kann manchmal während der Installation ausfallen, weil ein Knoten ausgefallen ist oder die Netzwerkverbindung zwischen Master und Worker nicht ordnungsgemäß funktioniert. Überprüfen Sie den Cluster und stellen Sie sicher, dass die Knoten ordnungsgemäß funktionieren.

Sie müssen den aktuellen Status des Clusters vom Masterknoten aus überprüfen, um sicherzustellen, dass die Knoten bereit sind. Wenn Sie die Verbindung zum Masterknoten getrennt haben, können Sie mit dem folgenden Befehl SSH wieder herstellen:

ssh ubuntu@

Führen Sie dann den folgenden Befehl aus, um den Status des Clusters abzurufen:

kubectl get nodes

Sie sehen eine Ausgabe ähnlich der folgenden:

OutputNAME      STATUS    ROLES     AGE       VERSION
master    Ready     master    1d        v1.14.0
worker1   Ready     <none>    1d        v1.14.0
worker2   Ready     <none>    1d        v1.14.0

Wenn alle Knoten den Wert "+ Bereit " für " STATUS +" haben, sind sie Teil des Clusters und können Workloads ausführen.

Wenn jedoch einige der Knoten "+ NotReady " als " STATUS " haben, kann dies bedeuten, dass die Arbeitsknoten ihre Einrichtung noch nicht abgeschlossen haben. Warten Sie etwa fünf bis zehn Minuten, bevor Sie ` kubectl get node ` erneut ausführen und die neue Ausgabe überprüfen. Wenn einige Knoten immer noch " NotReady +" als Status haben, müssen Sie möglicherweise die Befehle in den vorherigen Schritten überprüfen und erneut ausführen.

Nachdem Ihr Cluster erfolgreich überprüft wurde, planen wir eine Nginx-Beispielanwendung für den Cluster.

Schritt 7 - Ausführen einer Anwendung im Cluster

Sie können jetzt jede containerisierte Anwendung in Ihrem Cluster bereitstellen. Stellen Sie Nginx mit Deployments und Services bereit, um zu erfahren, wie diese Anwendung im Cluster bereitgestellt werden kann. Sie können die folgenden Befehle auch für andere containerisierte Anwendungen verwenden, vorausgesetzt, Sie ändern den Docker-Image-Namen und alle relevanten Flags (z. B. "+ ports " und " volume +").

Führen Sie im Masterknoten den folgenden Befehl aus, um eine Bereitstellung mit dem Namen "+ nginx +" zu erstellen:

kubectl create deployment  --image=

Eine Bereitstellung ist ein Kubernetes-Objekttyp, der sicherstellt, dass immer eine bestimmte Anzahl von Pods ausgeführt wird, die auf einer definierten Vorlage basieren, auch wenn der Pod während der Lebensdauer des Clusters abstürzt. Bei der obigen Bereitstellung wird ein Pod mit einem Container aus dem Nginx Docker Image der Docker-Registrierung erstellt.

Führen Sie als Nächstes den folgenden Befehl aus, um einen Dienst mit dem Namen "+ nginx +" zu erstellen, der die App öffentlich verfügbar macht. Dies geschieht über einen NodePort, ein Schema, das den Zugriff auf den Pod über einen beliebigen Port ermöglicht, der auf jedem Knoten des Clusters geöffnet ist:

kubectl expose deploy  --port  --target-port  --type NodePort

Services sind ein weiterer Typ von Kubernetes-Objekten, die interne Clusterdienste für interne und externe Clients verfügbar machen. Sie sind auch in der Lage, Anforderungen für den Lastenausgleich auf mehrere Pods zu verteilen. Sie sind ein wesentlicher Bestandteil von Kubernetes und interagieren häufig mit anderen Komponenten.

Führen Sie den folgenden Befehl aus:

kubectl get services

Dadurch wird ein Text ähnlich dem folgenden ausgegeben:

OutputNAME         TYPE        CLUSTER-IP       EXTERNAL-IP           PORT(S)             AGE
kubernetes   ClusterIP   10.96.0.1        <none>                443/TCP             1d
       NodePort    10.109.228.209   <none>                80:/TCP   40m

In der dritten Zeile der obigen Ausgabe können Sie den Port abrufen, auf dem Nginx ausgeführt wird. Kubernetes weist automatisch einen zufälligen Port zu, der größer als "+ 30000 +" ist, wobei sichergestellt wird, dass der Port nicht bereits an einen anderen Dienst gebunden ist.

Um zu testen, ob alles funktioniert, rufen Sie "+ http: //: " oder " http: //: +" über einen Browser auf Ihrem lokalen Computer auf. Sie sehen die vertraute Begrüßungsseite von Nginx.

Wenn Sie die Nginx-Anwendung entfernen möchten, löschen Sie zuerst den Dienst "+ nginx +" vom Masterknoten:

kubectl delete service

Führen Sie Folgendes aus, um sicherzustellen, dass der Dienst gelöscht wurde:

kubectl get services

Sie werden die folgende Ausgabe sehen:

OutputNAME         TYPE        CLUSTER-IP       EXTERNAL-IP           PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1        <none>                443/TCP        1d

Dann löschen Sie die Bereitstellung:

kubectl delete deployment

Führen Sie Folgendes aus, um zu bestätigen, dass dies funktioniert hat:

kubectl get deployments
OutputNo resources found.

Fazit

In diesem Handbuch haben Sie erfolgreich einen Kubernetes-Cluster unter Ubuntu 18.04 mit Kubeadm und Ansible für die Automatisierung eingerichtet.

Wenn Sie sich fragen, was Sie mit dem Cluster tun sollen, nachdem es eingerichtet wurde, ist es ein guter nächster Schritt, Ihre eigenen Anwendungen und Dienste auf dem Cluster bereitzustellen. Hier ist eine Liste von Links mit weiteren Informationen, die Sie bei diesem Vorgang unterstützen können:

  • Dockerizing applications - listet Beispiele auf, die beschreiben, wie Anwendungen mit Docker containerisiert werden.

  • Pod Overview - beschreibt detailliert, wie Pods funktionieren und in welcher Beziehung sie zu anderen Kubernetes-Objekten stehen. Pods sind in Kubernetes allgegenwärtig, sodass Sie Ihre Arbeit erleichtern, wenn Sie sie verstehen.

  • Deployments Overview - Bietet eine Übersicht über Bereitstellungen. Es ist hilfreich zu verstehen, wie Controller wie Bereitstellungen funktionieren, da sie häufig in zustandslosen Anwendungen zur Skalierung und zum automatisierten Heilen von fehlerhaften Anwendungen verwendet werden.

  • Services Overview - umfasst Services, ein weiteres häufig verwendetes Objekt in Kubernetes-Clustern. Um zustandslose und zustandsbehaftete Anwendungen ausführen zu können, müssen Sie die Arten von Diensten und die verfügbaren Optionen kennen.

Weitere wichtige Konzepte, die Sie untersuchen können, sind Volumes, Ingresses. und Secrets, die alle beim Bereitstellen von Produktionsanwendungen nützlich sind.

Kubernetes hat viele Funktionen und Features zu bieten. Die offizielle Kubernetes-Dokumentation ist der beste Ort, um Konzepte kennenzulernen, aufgabenspezifische Handbücher zu finden und API-Referenzen für verschiedene Objekte nachzuschlagen.

Related