Wie man Ports in einem Kubernetes-Service zuordnet

Einführung

In diesem Tutorial erhalten Sie ein umfassendes Verständnis von Kubernetes Services, einem grundlegenden Konzept im Kubernetes-Ekosystem. Sie lernen über die verschiedenen Arten von Services, wie Sie Ihre Anwendungen an das Netzwerk expose und die fortgeschrittenen Konzepte im Zusammenhang mit Kubernetes Services.

Das Verständnis von Kubernetes Services

Kubernetes Services sind ein grundlegendes Konzept im Kubernetes-Ekosystem und bieten eine Möglichkeit, Anwendungen, die in Pods laufen, an das Netzwerk zu expose. Services abstrahieren von den zugrunde liegenden Pods, sodass Clients auf die Anwendung zugreifen können, ohne die Details der Pods kennen zu müssen.

Kubernetes-Servicetypen

Kubernetes bietet verschiedene Servicetypen an, um verschiedene Netzwerkanforderungen zu erfüllen:

1. ClusterIP: Dies ist der Standard-Servicetyp, der den Service an einer internen Cluster-IP-Adresse expose. Ein solcher Service ist nur innerhalb des Clusters erreichbar.

graph LR
  Client --> ClusterIP
  ClusterIP --> Pods

2. NodePort: Dieser Servicetyp expose die Anwendung an jeder Node-IP-Adresse über einen statischen Port. Dadurch können externe Clients die Anwendung von außerhalb des Clusters aus zugreifen.

graph LR
  Client --> NodePort
  NodePort --> Nodes
  Nodes --> Pods

3. LoadBalancer: Dieser Servicetyp bereitet für die Anwendung einen Lastenausgleicher vor, typischerweise in Cloud-Umgebungen. Der Lastenausgleicher verteilt den Verkehr auf die Pods.

graph LR
  Client --> LoadBalancer
  LoadBalancer --> Nodes
  Nodes --> Pods

4. ExternalName: Dieser Servicetyp bindet den Service an einen DNS-Namen, ohne dass es Pods oder Endpunkte gibt. Dies ist nützlich für die Integration mit externen Diensten.

Service-Komponenten

Ein Kubernetes Service besteht aus mehreren wichtigen Komponenten:

1. Selector: Der Selector ist eine Menge von Labels, die bestimmen, welche Pods Teil des Services sein werden.
2. Port: Der Port, über den der Service erreichbar sein wird.
3. TargetPort: Der Port, auf dem die Pods lauschen.
4. ClusterIP: Die interne IP-Adresse, die dem Service zugewiesen wird.
5. Type: Der Typ des Services, wie zuvor beschrieben.

Hier ist eine Beispiel-Service-Konfiguration:

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 8080
  type: LoadBalancer

In diesem Beispiel wird der Service die Pods mit dem Label app: my-app am Port 80 expose und den Verkehr an den Port 8080 der Pods weiterleiten.

Das Expose von Kubernetes-Anwendungen

Sobald Sie einen Kubernetes Service definiert haben, ist der nächste Schritt, Ihre Anwendung der Außenwelt zu expose. Kubernetes bietet mehrere Möglichkeiten, dies zu erreichen, wobei jede ihre eigenen Vor- und Nachteile sowie Anwendungsfälle hat.

NodePort-Service

Der NodePort-Servicetyp expose die Anwendung an jeder Node-IP-Adresse über einen statischen Port. Dadurch können externe Clients die Anwendung von außerhalb des Clusters aus zugreifen. Hier ist ein Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: my-nodeport-service
spec:
  type: NodePort
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 8080

In diesem Beispiel wird der Service an jeder Node-IP-Adresse erreichbar sein, über einen zufällig zugewiesenen Port im Bereich von 30000 - 32767.

LoadBalancer-Service

Der LoadBalancer-Servicetyp bereitet für die Anwendung einen Lastenausgleicher vor, typischerweise in Cloud-Umgebungen. Der Lastenausgleicher verteilt den Verkehr auf die Pods. Hier ist ein Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: my-loadbalancer-service
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 8080

In diesem Beispiel wird der Cloud-Anbieter einen Lastenausgleicher bereitstellen und ihn so konfigurieren, dass er den Verkehr auf die Pods verteilt.

Ingress

Ingress ist eine Kubernetes-Ressource, die fortgeschrittene Routen- und Lastenausgleichsfunktionen bietet. Ingress ermöglicht es Ihnen, mehrere Services unter einer einzelnen IP-Adresse zu expose und kann Funktionen wie SSL/TLS-Termination, pfadbasiertes Routing und mehr verarbeiten. Hier ist ein Beispiel für eine Ingress-Konfiguration:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
    - host: example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: my-api-service
                port:
                  number: 80
          - path: /web
            pathType: Prefix
            backend:
              service:
                name: my-web-service
                port:
                  number: 80

In diesem Beispiel expose der Ingress zwei verschiedene Services, /api und /web, unter der Domain example.com.

Fortgeschrittene Konzepte von Kubernetes Services

Während die grundlegenden Kubernetes-Servicetypen viele Anwendungsfälle abdecken, gibt es einige fortgeschrittene Konzepte, die Ihnen mehr Flexibilität und Kontrolle über das Netzwerk Ihrer Anwendung bieten können.

Service Discovery

Kubernetes bietet integrierte Service Discovery-Mechanismen, die es Pods ermöglichen, sich gegenseitig zu finden und zu kommunizieren. Dies wird durch die Verwendung von Umgebungsvariablen und dem Kubernetes-DNS-Server erreicht.

Wenn ein neuer Service erstellt wird, weist Kubernetes ihm automatisch einen DNS-Namen im Format <service-name>.<namespace>.svc.cluster.local zu. Pods können dann diesen DNS-Namen verwenden, um sich an den Service zu verbinden.

Kubernetes injiziert auch Umgebungsvariablen für jeden Service, wie MY_SERVICE_HOST und MY_SERVICE_PORT, die Pods verwenden können, um sich an den Service zu verbinden.

Service Networking

Kubernetes verwendet die Komponente kube-proxy, um das Netzwerk für Services zu verwalten. kube-proxy ist für das Einrichten der erforderlichen iptables-Regeln und das Weiterleiten des Verkehrs an die entsprechenden Pods verantwortlich.

Kubernetes unterstützt mehrere Netzwerkmodelle, wie iptables und ipvs, die je nach Ihren Anforderungen konfiguriert werden können.

Service Skalierung

Kubernetes Services können sich automatisch auf- und herunterskalieren, basierend auf der Anzahl verfügbarer Pods. Wenn Sie Ihre Anwendung skalieren, indem Sie Pods hinzufügen oder entfernen, wird der Service automatisch seine Lastverteilung anpassen, um den Verkehr entsprechend zu verteilen.

Sie können auch fortgeschrittene Skalierungsoptionen konfigurieren, wie die horizontale Pod-Autoskalierung, um Ihre Anwendung automatisch basierend auf Metriken wie der CPU-Nutzung oder benutzerdefinierten Metriken zu skalieren.

Hier ist ein Beispiel für einen Horizontalen Pod Autoscaler:

apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: my-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        targetAverageUtilization: 50

In diesem Beispiel wird der Horizontale Pod Autoscaler die my-app-Deployment automatisch zwischen 2 und 10 Pods skalieren, basierend auf der durchschnittlichen CPU-Nutzung der Pods.

Zusammenfassung

In diesem Tutorial haben Sie über die verschiedenen Arten von Kubernetes Services gelernt, einschließlich ClusterIP, NodePort und LoadBalancer, und wie diese verwendet werden können, um Ihre Anwendungen an das Netzwerk zu expose. Sie haben auch die wichtigsten Komponenten eines Kubernetes Services untersucht und erfahren, wie Sie sie konfigurieren können. Indem Sie Kubernetes Services verstehen, können Sie Ihre in Pods laufenden Anwendungen effektiv verwalten und expose, sodass Clients auf Ihre Anwendung zugreifen können, ohne die Details der zugrunde liegenden Pods kennen zu müssen.