Ein Anfängerleitfaden zu Kubernetes

In diesem Leitfaden werden Sie in die Funktionsweise von Kubernetes und den Einstieg mit Kubernetes vorgestellt.

Was ist Kubernetes?

Kubernetes oder K8s ist eine kostenlose Open-Source-Plattform für die Verwaltung von Anwendungsumgebungen und -diensten von Container. Mit Kubernetes können Sie tragbare und hoch erweiterbare Containeranwendungen erstellen, die einfach bereitgestellt und verwalten können. Es wird üblicherweise neben Docker verwendet, um eine bessere Kontrolle über Containeranwendungen und -dienste zu entwickeln.

Funktionen von Kubernetes

Im Folgenden sind die wesentlichen Funktionen von Kubernetes aufgeführt:

1. Automatisierte Rollouts und Rollbacks für Fallfehler auftreten.
2. Automatische skalierbare Infrastruktur.
3. Horizontale Skalierung
4. Lastbalancer
5. Automatisierte Gesundheitsprüfungen und Selbstheilungsfähigkeiten.
6. Äußerst vorhersehbare Infrastruktur
7. Reittier- und Speichersysteme zum Ausführen von Anwendungen
8. Effiziente Ressourcenverbrauch
9. Jede Kubernetes -Einheit ist lose miteinander verbunden und kann als eigenständige Komponente wirken.
10. Automatische Verwaltung von Sicherheits-, Netzwerk- und Netzwerkkomponenten.

Kubernetes Architektur

Wenn Sie die Kubernetes -Architektur verstehen, können Sie ein tieferes Wissen über die Arbeit mit Kubernetes erlangen.

Im Folgenden finden Sie Hardwarekomponenten der Kubernetes -Architektur:

Ein Knoten ist eine Darstellung einer einzelnen Maschine in einem Kubernetes -Cluster. Der Knoten repräsentiert eine einzelne Arbeitermaschine, entweder in einer virtuellen Maschine oder in einer physischen Hardware.

Jeder Knoten in Kubernetes umfasst verschiedene Kubernetes-Softwarekomponenten wie Pods, Kubulet, Kube-Proxy und die Container-Laufzeit wie Docker.

Ein Pod bezieht sich auf eine oder mehrere mit Container angelegte Anwendungen,. Kubernetes verwaltet die jeweiligen Pods anstelle der Container und erstellt Repliken, wenn einer von ihnen fehlschlägt. Pods bieten gemeinsame Ressourcen wie Netzwerkschnittstellen und Speichergeräte an.

Container/Container-Runtime

Ein Container ist ein isoliertes, in sich geschlossenes Softwarepaket. Ein Container enthält alles, was zum Ausführen einer Anwendung erforderlich ist, einschließlich Code, Systembibliotheken und anderen Abhängigkeiten. Sobald ein Container bereitgestellt ist, können Sie den Code nicht ändern, da er unveränderlich ist. Standardmäßig wird Kubernetes -Container -Laufzeit von Docker bereitgestellt.

Kuberett

Das KuBelet ist eine einfache Anwendung, die die Kommunikation zwischen dem Knoten und dem Masterknoten ermöglicht. Es ist verantwortlich für die Verwaltung der Schoten und der Container. Der Master -Knoten verwendet die Kubectl, um die erforderlichen Aktionen an den spezifischen Knoten auszuführen.

Kube-Proxy

Der Kube-Proxy ist ein Netzwerkproxy, der in allen Kubernetes-Knoten verfügbar ist. Es verwaltet die Netzwerkkommunikation innerhalb und außerhalb des Clusters.

Cluster

Ein Cluster ist eine Sammlung von Kubernetes -Knoten, die ihre Ressourcen zusammenfassen, um eine leistungsstarke Maschine zu erstellen. Die von den Kubernetes -Knoten geteilten Ressourcen umfassen Speicher, CPU und Festplatten.

Ein Kubernetes -Cluster besteht aus einem Masterknoten und anderen Sklavenknoten. Der Master -Knoten steuert den Kubernetes -Cluster, einschließlich Planung und Skalierungsanwendungen, das Schieben und Anwenden von Updates sowie die Verwaltung der Clusterzustände.

Anhaltende Bände

Persistente Bände werden verwendet, um Daten in einem Kubernetes -Cluster zu speichern. Persistente Bände werden aus verschiedenen Bänden aus den Clusterknoten bestehen. Sobald ein Knoten im Cluster entfernt oder hinzugefügt wurde, verteilt der Masterknoten die Arbeit effizient.

Eindringen

Der Kubernetes -Eingang ist ein API. Ingress verwendet typischerweise ein HTTP/HTTPS -Protokoll, um die Dienste freizulegen. Ein Eingang wird mit einem Eingress -Controller oder einem Lastausgleich in einen Cluster implementiert.

Meister

Der Master, auch als Kontrollebene bekannt, bezieht sich auf die zentrale Steuerkomponente für die Kubernetes -Architektur. Es ist verantwortlich für die Verwaltung der Arbeitsbelastung und die Schnittstelle zwischen dem Cluster und seinen Mitgliedern.

Der Master besteht aus verschiedenen Komponenten. Diese beinhalten:

1. Kontrollmanager
2. Planer
3. API -Server
4. Etcd

Kontrollmanager

Der Kontrollmanager oder Kube-Control-Manager ist für das Ausführen und Verwalten des Clusters verantwortlich. Der Control Dämon sammelt Informationen über den Cluster und meldet sie an den API -Server zurück.

Planer

Der Kube-Scheduler oder einfach der Scheduler ist für die Verteilung der Arbeitsbelastung verantwortlich. Es führt Funktionen wie die Bestimmung aus, ob der Cluster gesund ist, die Schaffung von Behälter und mehr.

Es verfolgt Ressourcen wie Speicher und CPU und plant Pods an den entsprechenden Rechenknoten.

API -Server

Der Kube-Apiserver ist eine Front-End-Schnittstelle zum Kubernetes-Master. Sie können mit dem Kubernetes -Cluster sprechen. Sobald der API -Server eine Anforderung empfängt, wird festgelegt, ob die Anforderung gültig ist, und verarbeitet sie, wenn wahr ist.

Um mit dem API-Server interagieren.

Etcd

Die ETCD ist eine Schlüsselwertdatenbank, die für die Speicherung von Konfigurationsdaten und Informationen zum Status des Kubernetes-Clusters verantwortlich ist. Es empfängt Befehle von anderen Clusterkomponenten und führt die erforderlichen Aktionen aus.

Kubernetes laufen

In diesem Abschnitt werden mit Kubernetes begonnen. Diese Illustration wird an einem Debian -System getestet.

Starten Sie das Terminal und aktualisieren Sie Ihr System.

sudo apt-Get-Update
sudo apt-get upgrade

Installieren Sie als nächstes verschiedene Anforderungen, wie im folgenden Befehl gezeigt:

sudo apt-get installieren curl gnupg ca-zertifikate apt-transport-httpps

Docker installieren

Als nächstes müssen wir Docker als Kubernetes als Containerlaufzeit verwenden. Die folgenden Anweisungen gelten für das Debian -Betriebssystem. Erfahren Sie, wie Sie Docker in Ihrem System installieren.

Fügen Sie den offiziellen GPG -Schlüssel der Docker hinzu:

curl -fssl https: // herunterladen.Docker.com/linux/debian/gpg | sudo
GPG--DEARMOR -O/usr/share/keyrings/docker-archive-keyring.gpg

Richten Sie als Nächstes die Docker -Repositorys in die Quellen ein, wie im Befehl gezeigt:

echo \
"Deb [Arch = AMD64 signiert für =/usr/share/keyrings/docker-archive-keyring.gpg] https: // herunterladen.Docker.com/linux/debian \
$ (lsb_release -cs) stabil "| sudo tee/etc/apt/Quellen.Liste.D/Docker.Liste> /dev /null

Als nächstes aktualisieren und installieren Sie Docker:

sudo apt-Get Update && sudo apt-Get Installieren Sie Docker-CE-Container.io docker-cli

Starten Sie schließlich den Docker -Service und aktivieren Sie den Docker -Service

sudo systemctl aktivieren docker.Service
sudo systemctl starten docker.Service

Installieren Sie Kubernetes

Als nächstes müssen wir Kubernetes im System installieren. In ähnlicher Weise werden die Anweisungen in diesem Leitfaden auf einem Debian -System getestet.

Erfahren Sie, wie Sie Kubernetes in Ihrem System installieren

Starten Sie mit dem Herunterladen des Google Cloud Signing -Schlüssels:

sudo curl -fsslo/usr/share/keyrings/kubernetes-archive-keyring.gpg https: // pakete.Wolke.Google.com/apt/doc/apt-key.gpg

Als nächstes fügen Sie Kubernetes -Repository hinzu:

Echo "Deb [signiert für =/usr/shary/keyrings/kubernetes-archive-keyring.gpg] https: // apt.Kubernetes.IO/Kubernetes-Xenial Main "| sudo tee/etc/apt/Quellen.Liste.D/Kubernetes.Liste

Schließlich aktualisieren und installieren Sie Kubernetes -Komponenten

sudo apt-Get-Update

sudo apt-get install kubectl kubrett kubeadm kubernetes kubernetes-cni

Initialiaze kubernetes masterknoten

Der nächste Schritt besteht darin, den Kubernetes -Masterknoten zu starten. Bevor dies dies tun, wird empfohlen, den Tausch auszuschalten.

Verwenden Sie dazu den Befehl:

sudo swapoff -a

Sobald Sie den Swap ausschalten, initialisieren Sie den Masterknoten mit den Befehlen:

sudo kubeadm init

Sobald der Befehl erfolgreich ausgeführt wird, sollten Sie drei Befehle erhalten.

Kopieren und führen Sie die Befehle aus und führen Sie sie aus:

mkdir -p $ home/.kube \
sudo cp -i/etc/kubernetes/admin.Conf $ Home/.kube/config \
sudo chown $ (id -u): $ (id -g) $ home/.kube/config

POD -Netzwerk bereitstellen

Der nächste Schritt besteht darin, ein POD -Netzwerk bereitzustellen. In diesem Leitfaden verwenden wir das AWS VPC CNI für Kubernetes.

Verwenden Sie den Befehl als:

sudo kubectl anwenden -f https: // raw.GithubuSercontent.com/AWS/Amazon-VPC-CNI-K8S/V1.8.0/config/v1.8/AWS-K8S-CNI.Yaml

Stellen Sie nach Abschluss sicher, dass der Cluster in Betrieb ist, indem Sie den Befehl ausführen:

sudo kubectl cluster-info

Es wäre am besten, wenn Sie wie gezeigt ausgeben würden:

Die Kubernetes -Steuerebene läuft unter https: // 192.168.43.29: 6443
Coredns läuft unter https: // 192.168.43.29: 6443/API/V1/Namespaces/Kube-System/Services/Kube-DNS: DNS/Proxy

Verwenden Sie den Befehl, um alle laufenden Knoten anzuzeigen:

sudo kubectl bekommen Knoten

Eine Anwendung bereitstellen

Lassen Sie uns eine MySQL -Anwendung bereitstellen und den Dienst auf Port 3306 freilegen. Verwenden Sie den Befehl wie gezeigt:

sudo kubectl anwenden -f https: // k8s.IO/Beispiele/Application/Mysql/MySQL-Deployment.Yaml
sudo kubectl expose Deployment mySQL --port = 3306 --Name = MySQL-Server

Verwenden Sie den Befehl, um die Liste der Bereitstellungen anzuzeigen:

Kubectl erhalten Bereitstellungen

Verwenden Sie den Befehl, um Informationen über die Pods zu erhalten:

sudo kubectl beschreibt Pods

Um zusammenzufassen

Kubernetes ist ein robustes Tool für Containerbereitstellungen und -verwaltung. Dieses Tutorial kratzt nur die Oberfläche von Kubernetes und seine Fähigkeiten.