Auf einen Blick: Kubernetes verwendet Port-, TargetPort- und NodePort-Konfigurationen, um containerisierte Anwendungen zu verwalten. Port stellt Dienste innerhalb des Clusters frei, TargetPort leitet Anfragen an bestimmte Pod-Ports, und NodePort stellt den externen Zugriff über die IP-Adresse des Knotens bereit.
- Kubernetes automatisiert Containerverwaltung, Skalierung und Überwachung.
- Das Verständnis der Portkonfigurationen ist entscheidend für eine effektive Anwendungsbereitstellung und -verwaltung.
Kubernetes und Ports
Kubernetes ist ein Open-Source-Tool, das containerisierte Anwendungen orchestriert. Das Kubernetes-Tool stellt sicher, dass Container korrekt laufen, indem es Pods auf verschiedenen Servern oder Knoten überwacht. Es verwaltet automatisch Reaktionen auf Containerausfälle, startet oder ersetzt Pods bei Bedarf erneut. Es skaliert sie je nach Nachfrage hoch oder runter und verteilt die Rechenlast auf Container, um die Arbeit auszugleichen. Es eliminiert die manuelle Arbeit bei der Verwaltung, Skalierung und Wartung großer und komplexer Anwendungen. Kubernetes nutzt Netzwerke, einschließlich Ports und Services, um die Kommunikation zwischen Pods und anderen Ressourcen zu erleichtern.
Kubernetes Services Port-Konfigurationen: Port vs. TargetPort vs NodePort
In Kubernetes gibt es mehrere verschiedene Portkonfigurationen für Kubernetes-Dienste:
- Port stellt den Kubernetes-Service auf dem angegebenen Port innerhalb des Clusters frei. Andere Pods innerhalb des Clusters können mit diesem Server auf dem angegebenen Port kommunizieren.
- TargetPort ist der Port, an den der Dienst Anfragen sendet, auf dem dein Pod abhört. Deine Anwendung im Container muss auch auf diesem Port lauschten.
- NodePort stellt einen Dienst extern dem Cluster über die IP-Adresse des Zielknotens und den NodePort zur Verfügung. NodePort ist die Standardeinstellung, wenn das Portfeld nicht angegeben ist.
Schauen wir uns an, wie du diese Ports in deinem Kubernetes-Manifest verwenden kannst.
Verwendung von Port, TargetPort und NodePort in Kubernetes
apiVersion: v1
kind: Service
metadata:
name: hello-world
spec:
type: NodePort
selector:
app: hello-world
ports:
- protocol: TCP
port: 8080
targetPort: 80
nodePort: 30036
Aus den obigen Beispielen wird der Hello-World-Dienst intern den Clusteranwendungen am Port 8080 und extern dem Cluster auf der Knoten-IP-Adresse 30036 zugänglich gemacht. Er leitet auch Anfragen an Pods mit dem Label "app: hello-world" am Port 80 weiter. Die Konfiguration der obigen Einstellungen kann mit dem Befehl überprüft werden:
$ kubectl describe service hello-world
Erstelle einen Pod, der nginx ausführt, an den der Dienst Anfragen weiterleitet:
apiVersion: v1
kind: Pod
metadata:
name: nginx
labels:
app: hello-world
spec:
containers:
- name: nginx
image: nginx
ports:
- containerPort: 80
Um die obige Konfiguration zu testen und zu demonstrieren, können wir einen Pod erstellen, der einen Ubuntu-Container ausführt, um einige Curl-Befehle zur Verifizierung der Konnektivität auszuführen.
$ kubectl run -i --tty ubuntu --image=ubuntu --restart=Never -- sh
Von diesem Pod aus führen Sie folgende Befehle aus: Curlen Sie den Service auf dem im Kubernetes-Manifest definierten 'Port' für den Service.
$ curl hello-world:8080
Das beweist, dass das Curling des Kubernetes-Dienstes auf Port 80 die Anfrage an unseren nginx-Pod-Listening auf Port 80 weiterleitet. Um den NodePort auf deinem Rechner zu testen (nicht im Ubuntu-Pod), musst du die IP-Adresse des Knotens finden, auf dem dein Pod läuft.
$ kubectl describe pod nginx
Jetzt kannst du die Node-IP-Adresse und den NodePort curlen und solltest den nginx-Container erreichen, der hinter dem Kubernetes-Service läuft.
Fazit
Das Beherrschen von Kubernetes, insbesondere die Nutzung von Pods und Ports, ist unerlässlich, um containerisierte Anwendungen in großem Umfang effizient zu verwalten. Da sich Kubernetes weiter weiterentwickelt und seine Verbreitung branchenübergreifend wächst, ermöglicht das Verständnis, wie man Netzwerke innerhalb der Plattform konfiguriert und optimiert, Anwendungen mit größerer Präzision und Zuverlässigkeit bereitzustellen, zu verwalten und zu skalieren.
Kubernetes-Leitfaden
- Was ist Kubernetes (K8s)? Ein Tutorial zu den Grundlagen von Kubernetes
- Kubernetes Best Practices für verbesserte Cluster-Effizienz
- Best Practices: Wie man Anwendungen für Kubernetes architekt
- Kubernetes Pods: Eine Einführung
- Kubernetes ReplicaSets: Eine kurze Einführung
- Kubernetes-Deployments vollständig erklärt
- Wie man Kubernetes DaemonSets verwendet und verwaltet
- Wie Kubernetes-Dienste funktionieren
- Verwendung von Kubernetes Port, TargetPort und NodePort
- Erstellen und verwenden von ConfigMaps in Kubernetes
- Einführung in Kubernetes-Geheimnisse
- Kubernetes-Netzwerkgrundlagen
- Kubernetes-Ingress erklärt
- Einführung in Kubernetes Helm Charts
- Was ist das Kubernetes-Operator-Muster?
- Bereitstellung von PostgreSQL als StatefulSet in Kubernetes
- Kubernetes Custom Resource Definition (CRDs) erklärt
- 3 Kubernetes-Muster für Cloud-native Anwendungen
- Kubernetes Compute-Ressourcen erklärt
- Kubernetes-Sicherheit für DevOps-Pipelines
- Verwendung von Spinnaker mit Kubernetes für Continuous Delivery
- Kubernetes-Multi-Cluster: Wie und warum man sie verwendet.
- Kubernetes-Überwachung: Ein umfassender Leitfaden
- Kubernetes vs. Docker: Ein kurzer Vergleich
- Kubernetes vs. Docker Swarm: Vergleich von Container-Orchestrierungstools
- Kubernetes vs. OpenShift: Was ist der Unterschied?
- Kubernetes-Zertifizierungen: Wie und warum man zertifiziert wird
Diese Beiträge sind meine eigenen und spiegeln nicht unbedingt die Position, Strategien oder Meinung von BMC wider.