Was ist der Unterschied zwischen den Diensttypen ClusterIP, NodePort und LoadBalancer in Kubernetes?

1 - Ich lese die Dokumentation und bin etwas verwirrt mit dem Wortlaut. Es sagt:

ClusterIP : Macht den Dienst auf einer clusterinternen IP verfügbar . Durch Auswahl dieses Werts ist der Dienst nur innerhalb des Clusters erreichbar. Dies ist der Standarddiensttyp

NodePort : Macht den Dienst auf der IP jedes Knotens an einem statischen Port (dem NodePort) verfügbar. Ein ClusterIP-Dienst, an den der NodePort-Dienst weiterleitet, wird automatisch erstellt. Sie können den NodePort-Dienst von außerhalb des Clusters auf Anfrage kontaktieren <NodeIP>:<NodePort>.

LoadBalancer : Macht den Dienst mithilfe des Load Balancers eines Cloud-Anbieters extern verfügbar . NodePort- und ClusterIP-Dienste, an die der externe Load Balancer weitergeleitet wird, werden automatisch erstellt.

Verwendet der NodePort-Diensttyp weiterhin den ClusterIPPort, jedoch nur an einem anderen Port, der für externe Clients geöffnet ist? Also in diesem Fall ist <NodeIP>:<NodePort>das gleiche wie <ClusterIP>:<NodePort>?

Oder ist die NodeIPtatsächlich gefundene IP beim Ausführen kubectl get nodesund nicht die virtuelle IP, die für den ClusterIP-Diensttyp verwendet wird?

2 - Auch im Diagramm über den folgenden Link:

http://kubernetes.io/images/docs/services-iptables-overview.svg

Gibt es einen bestimmten Grund, warum das Clientin der ist Node? Ich nahm an, dass es sich Clusterbei einem ClusterIP-Diensttyp innerhalb eines befinden müsste.

Wenn dasselbe Diagramm für NodePort gezeichnet würde, wäre es dann gültig, den Client vollständig außerhalb von Nodeund zu zeichnen, Clusteroder fehlt mir der Punkt vollständig?

Ein ClusterIP stellt Folgendes bereit:

• spec.clusterIp:spec.ports[*].port

Sie können nur innerhalb des Clusters auf diesen Dienst zugreifen. Es ist von seinem spec.clusterIpHafen aus zugänglich . Wenn a festgelegt spec.ports[*].targetPortist, wird es vom Port zum Zielport weitergeleitet. Die CLUSTER-IP, die Sie beim Aufrufen erhalten, kubectl get servicesist die IP, die diesem Dienst innerhalb des Clusters intern zugewiesen wurde.

Ein NodePort macht Folgendes verfügbar:

• <NodeIP>:spec.ports[*].nodePort
• spec.clusterIp:spec.ports[*].port

Wenn Sie über die externe IP-Adresse des Knotens auf diesen Dienst auf einem NodePort zugreifen, wird die Anforderung an weitergeleitet spec.clusterIp:spec.ports[*].port, die sie spec.ports[*].targetPortgegebenenfalls an Ihre weiterleitet . Auf diesen Dienst kann ebenso wie auf ClusterIP zugegriffen werden.

Ihre NodeIPs sind die externen IP-Adressen der Knoten. Sie können nicht von auf auf Ihren Dienst zugreifen <ClusterIP>:spec.ports[*].nodePort.

Ein LoadBalancer macht Folgendes verfügbar:

• spec.loadBalancerIp:spec.ports[*].port
• <NodeIP>:spec.ports[*].nodePort
• spec.clusterIp:spec.ports[*].port

Sie können auf diesen Dienst über die IP-Adresse Ihres Load Balancers zugreifen, die Ihre Anforderung an einen NodePort weiterleitet, der die Anforderung wiederum an den ClusterIP-Port weiterleitet. Sie können auf diesen Dienst wie auf einen NodePort- oder einen ClusterIP-Dienst zugreifen.

Um für jeden zu klären, der auf einer einfacheren Ebene nach dem Unterschied zwischen den 3 sucht. Sie können Ihren Service mit minimaler ClusterIp (innerhalb des k8s-Clusters) oder größerer Exposition mit NodePort (innerhalb des Clusters außerhalb des k8s-Clusters) oder LoadBalancer (externe Welt oder was auch immer Sie in Ihrer LB definiert haben) verfügbar machen.

ClusterIp-Exposition <NodePort-Exposition <LoadBalancer-Exposition

• ClusterIp
  Expose-Dienst über k8s-Cluster mitip/name:port
• NodePort
  Expose-Dienst über interne Netzwerk- VMs, auch außerhalb von k8sip/name:port
• LoadBalancer
  Expose-Dienst über die Außenwelt oder was auch immer Sie in Ihrer LB definiert haben.

ClusterIP: Dienste sind über Pods / Dienste im Cluster erreichbar.
Wenn ich einen Dienst namens myservice im Standard-Namespace vom Typ ClusterIP erstelle, wird die folgende vorhersehbare statische DNS-Adresse für den Dienst erstellt:

myservice.default.svc.cluster.local (oder nur myservice.default oder nach Pods im Standard-Namespace funktioniert nur "myservice")

Und dieser DNS-Name kann nur von Pods und Diensten innerhalb des Clusters aufgelöst werden.

NodePort: Dienste sind für Clients im selben LAN / für dieselben Clients erreichbar, die die K8s-Hostknoten (und Pods / Dienste im Cluster) anpingen können
Ich kann diesen Dienst nicht erreichen.) Wenn ich einen Dienst namens mynodeportservice im Namespace mynamespace vom Typ NodePort in einem 3-Knoten-Kubernetes-Cluster erstelle. Anschließend wird ein Dienst vom Typ ClusterIP erstellt, der von Clients im Cluster unter der folgenden vorhersehbaren statischen DNS-Adresse erreicht werden kann:

mynodeportservice.mynamespace.svc.cluster.local (oder einfach mynodeportservice.mynamespace)

Für jeden Port, den mynodeportservice auf einem Nodeport im Bereich von 30000 - 32767 abhört, wird zufällig ausgewählt. Damit externe Clients außerhalb des Clusters den innerhalb des Clusters vorhandenen ClusterIP-Dienst erreichen können. Nehmen wir an, unsere 3 K8-Hostknoten haben IPs 10.10.10.1, 10.10.10.2, 10.10.10.3, der Kubernetes-Dienst überwacht Port 80 und der zufällig ausgewählte Knotenport war 31852.

Ein Client, der außerhalb des Clusters existiert, konnte ihn besuchen 10.10.10.1:31852, 10.10.10.2:31852 oder 10.10.10.3:31852 (da NodePort von jedem Kubernetes-Hostknoten abgehört wird) Kubeproxy leitet die Anforderung an den Port 80 von mynodeportservice weiter.

LoadBalancer: Dienste sind für alle erreichbar, die mit dem Internet verbunden sind * (Gemeinsame Architektur ist, dass L4 LB im Internet öffentlich zugänglich ist, indem es in eine DMZ gestellt oder sowohl eine private als auch eine öffentliche IP-Adresse zugewiesen wird und sich k8s-Hostknoten in einem privaten Subnetz befinden)
( Hinweis: Dies ist der einzige Diensttyp, der in 100% der Kubernetes-Implementierungen nicht funktioniert, wie z. B. Bare-Metal-Kubernetes. Er funktioniert, wenn Kubernetes Cloud-Provider-Integrationen hat.)

Wenn Sie mylbservice erstellen, wird eine L4 LB-VM erzeugt (ein Cluster-IP-Dienst und ein NodePort-Dienst werden implizit ebenfalls erzeugt). Diesmal ist unser NodePort 30222. Die Idee ist, dass der L4 LB eine öffentliche IP von 1.2.3.4 hat und den Lastausgleich und den Datenverkehr an die 3 K8s-Hostknoten mit privaten IP-Adressen weiterleitet. (10.10.10.1:30222, 10.10.10.2:30222, 10.10.10.3:30222) und dann leitet Kube Proxy es an den Dienst vom Typ ClusterIP weiter, der im Cluster vorhanden ist.

Sie haben auch gefragt: Verwendet der NodePort-Diensttyp noch ClusterIP? Ja *
Oder ist die NodeIP tatsächlich die IP, die beim Ausführen von kubectl get node gefunden wurde? Auch Ja *

Zeichnen wir eine Parallele zwischen den Grundlagen:
Ein Container befindet sich in einem Pod. Ein Pod befindet sich in einem Replikat. Ein Replikatsatz befindet sich in einer Bereitstellung.
Ähnlich:
Ein ClusterIP-Dienst ist Teil eines NodePort-Dienstes. Ein NodePort-Dienst ist Teil eines Load Balancer-Dienstes.

In dem von Ihnen gezeigten Diagramm wäre der Client ein Pod innerhalb des Clusters.

Nehmen wir an, Sie haben eine Ubuntu-VM auf Ihrem lokalen Computer erstellt. Die IP-Adresse lautet 192.168.1.104 .

Sie melden sich bei VM an und installieren Kubernetes. Dann haben Sie einen Pod erstellt, auf dem ein Nginx-Image ausgeführt wird.

1- Wenn Sie auf diesen Nginx-Pod in Ihrer VM zugreifen möchten, erstellen Sie ein ClusterIP , das an diesen Pod gebunden ist, zum Beispiel:

$ kubectl expose deployment nginxapp --name=nginxclusterip --port=80 --target-port=8080

Dann können Sie in Ihrem Browser die IP-Adresse von nginxclusterip mit Port 80 eingeben, wie:

http://10.152.183.2:80

2- Wenn Sie von Ihrem Host-Computer aus auf diesen Nginx-Pod zugreifen möchten, müssen Sie Ihre Bereitstellung mit NodePort verfügbar machen . Beispielsweise:

$ kubectl expose deployment nginxapp --name=nginxnodeport --port=80 --target-port=8080 --type=NodePort

Jetzt können Sie von Ihrem Host-Computer aus wie folgt auf nginx zugreifen:

http://192.168.1.104:31865/

In meinem Dashboard werden sie wie folgt angezeigt:

Das folgende Diagramm zeigt die grundlegende Beziehung.

Auch wenn diese Frage bereits eine Antwort hat, werde ich eine andere zur Verfügung stellen, vielleicht mit einigen weiteren Bildern, um ein besseres Verständnis zu haben.

1. ClusterIP ist der Standarddiensttyp in Kubernetes. Mit diesem Typ erhalten Sie einen Dienst innerhalb des Clusters. Auf diese Weise können andere Anwendungen aus dem Cluster über den Kubernetes-Proxy auf den Dienst zugreifen.

Ich sollte erwähnen, dass diese Art von Service nicht zur Offenlegung von Produktionsservices verwendet werden sollte. Es kann jedoch für verwendet werden

• Debugging der Integration zwischen Diensten;
• Zugriff auf interne Dienste, die nicht geschäftsbezogene Daten verfügbar machen (Überwachungs-Dashboards).

Die Anfrage wird folgendermaßen ausgeführt: Verkehr -> K8s-Proxy -> K8s-Dienst (ClusterIP) -> Pods und wird im folgenden Bild angezeigt.

2. NodePort ist die primitivste Methode, um externen Datenverkehr zu akzeptieren und an die kubernetes-Dienste weiterzuleiten. Wie der Name schon sagt, öffnet der NodePort-Diensttyp einen bestimmten Port auf allen virtuellen Maschinen, bei denen es sich tatsächlich um die Kubernetes-Knoten handelt, damit der an diesen bestimmten Port gesendete Datenverkehr an den Dienst weitergeleitet werden kann.

Der NodePort-Diensttyp hat einige Nachteile:

• Es ist nur ein Dienst pro Port erforderlich.
• Wenn die IP der virtuellen Maschine geändert wird, müssen einige Änderungen im Cluster vorgenommen werden.
• Es kann nur ein Port zwischen 3000-32767 verwendet werden.

Die Anforderung lautet wie folgt: Verkehr -> auf der virtuellen Maschine verfügbarer Port -> K8s-Dienst (NodePort) -> Pods und wird im folgenden Bild angezeigt:

3. LoadBalancer ist die Standardmethode, um einen Dienst dem Internet zugänglich zu machen. Wenn Sie einen Dienst direkt verfügbar machen und den gesamten Datenverkehr an einem bestimmten Port an den Dienst weiterleiten möchten, ist dies der richtige Weg. Außerdem beinhaltet der LoadBalancer-Diensttyp keine Filterung oder Weiterleitung. Außerdem können Sie TCP-, UDP- und HTTP-gRPC-Verkehr an ihn senden.

Nachteil: Jeder Dienst, der über einen LoadBalancer verfügbar gemacht wird, hat eine eigene IP-Adresse, und jeder Dienst wird über einen einzelnen LoadBalancer verfügbar gemacht, was teuer werden kann.

Die Anforderung hat den folgenden Pfad: Verkehr -> LoadBalancer -> K8s-Dienst -> Pods und wird im folgenden Bild angezeigt.

1. clusterIP: IP, auf die innerhalb des Clusters zugegriffen werden kann (über Knoten innerhalb des d-Clusters).

nodeA : pod1 => clusterIP1, pod2 => clusterIP2
nodeB : pod3 => clusterIP3.

pod3 kann über ihr clusterIP-Netzwerk mit pod1 kommunizieren.

2. nodeport: Um Pods von außerhalb des Clusters über nodeIP: nodeport zugänglich zu machen, wird ClusterIP oben als ClusterIP-Netzwerk erstellt / beibehalten.

nodeA => nodeIPA : nodeportX
nodeB => nodeIPB : nodeportX

Sie können entweder über nodeIPA: nodeportX ODER nodeIPB: nodeportX auf den Dienst auf pod1 zugreifen. In beiden Fällen funktioniert es, da der kube-proxy (der auf jedem Knoten installiert ist) Ihre Anfrage empfängt und sie über das clusterIP-Netzwerk auf die Knoten verteilt [umleiten (Begriff iptables)].

3. Lastenausgleicher

Stellen Sie LB einfach in den Vordergrund, damit der eingehende Datenverkehr an nodeIPA: nodeportX und nodeIPB: nodeportX verteilt wird, und fahren Sie dann mit dem obigen Prozessablauf Nummer 2 fort.