TOC

So erstellen Sie einen Kubernetes-Cluster mit Kubeadm unter CentOS 7

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. Durch die Verwendung dieser Tools werden die Erstellung zusätzlicher Cluster oder die Neuerstellung vorhandener Cluster viel einfacher und 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 werden Ansible auch lokal konfigurieren, damit es mit Ihren Remote-Servern kommunizieren und Befehle ausführen kann. Dazu erstellen Sie eine "+ hosts +" - Datei mit Inventarinformationen wie den IP-Adressen Ihrer Server und den Gruppen, zu denen jeder Server gehört.

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 " vi +" oder Ihrem bevorzugten Texteditor:

vi ~/kube-cluster/hosts

Drücken Sie + i +, um den folgenden Text in die Datei einzufügen, 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

Wenn Sie fertig sind, drücken Sie "+ ESC " gefolgt von ": wq +", um die Änderungen in die Datei zu schreiben und zu beenden.

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.

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 - Installieren der Kubernetes-Abhängigkeiten

In diesem Abschnitt installieren Sie die für Kubernetes erforderlichen Pakete auf Betriebssystemebene mit CentOS '+ yum +' - Paketmanager. Diese Pakete sind:

  • Docker - eine Container-Laufzeit. Dies 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:

vi ~/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
    yum:
      name: docker
      state: present
      update_cache: true

  - name: start Docker
    service:
      name: docker
      state: started

  - name: disable SELinux
    command: setenforce 0

  - name: disable SELinux on reboot
    selinux:
      state: disabled

  - name: ensure net.bridge.bridge-nf-call-ip6tables is set to 1
    sysctl:
     name: net.bridge.bridge-nf-call-ip6tables
     value: 1
     state: present

  - name: ensure net.bridge.bridge-nf-call-iptables is set to 1
    sysctl:
     name: net.bridge.bridge-nf-call-iptables
     value: 1
     state: present

  - name: add Kubernetes' YUM repository
    yum_repository:
     name: Kubernetes
     description: Kubernetes YUM repository
     baseurl: https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
     gpgkey: https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
     gpgcheck: yes

  - name: install kubelet
    yum:
       name: kubelet-1.14.0
       state: present
       update_cache: true

  - name: install kubeadm
    yum:
       name: kubeadm-1.14.0
       state: present

  - name: start kubelet
    service:
      name: kubelet
      enabled: yes
      state: started

- hosts: master
 become: yes
 tasks:
  - name: install kubectl
    yum:
       name: kubectl-1.14.0
       state: present
       allow_downgrade: yes

Das erste Spiel im Spielbuch führt Folgendes aus:

  • Installiert Docker, die Container-Laufzeit.

  • Startet den Docker-Dienst.

  • Deaktiviert SELinux, da es von Kubernetes noch nicht vollständig unterstützt wird.

  • Legt einige netfilter-bezogene + sysctl + - Werte fest, die für die Vernetzung erforderlich sind. Auf diese Weise kann Kubernetes iptables-Regeln für den Empfang von überbrücktem IPv4- und IPv6-Netzwerkverkehr auf den Knoten festlegen.

  • Fügt das Kubernetes YUM-Repository zu den Repository-Listen Ihrer Remote-Server 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:

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 [disable SELinux] ****
changed: [master]
changed: [worker1]
changed: [worker2]

TASK [disable SELinux on reboot] ****
changed: [master]
changed: [worker1]
changed: [worker2]

TASK [ensure net.bridge.bridge-nf-call-ip6tables is set to 1] ****
changed: [master]
changed: [worker1]
changed: [worker2]

TASK [ensure net.bridge.bridge-nf-call-iptables is set to 1] ****
changed: [master]
changed: [worker1]
changed: [worker2]

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

TASK [add Kubernetes' YUM 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]

TASK [start kubelet] ****
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:

vi ~/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: centos
     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/centos/.kube/config
       remote_src: yes
       owner: centos

   - name: install Pod network
     become: yes
     become_user: centos
     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 / centos". 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 Basisverzeichnis Ihres Nicht-Root-Benutzers * centos *. 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 aus:

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 centos@

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 +":

vi ~/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 }} --ignore-preflight-errors all  >> 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:

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 centos@

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 CentOS 7 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 - Hier erhalten Sie eine Übersicht über die 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 - Dies 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