Im Zusammenhang mit Kubernetes beschreibt der Begriff „Bereitstellung“ eine Methode, um Pods mit containerbasierten Anwendungen zu starten und sicherzustellen, dass immer die erforderliche Anzahl von Replikaten im Cluster ausgeführt wird.

Ein Service stellt diesen Pods eine Schnittstelle für den Netzwerkzugriff entweder innerhalb des Clusters oder zwischen externen Prozessen und dem Service zur Verfügung.

Kubernetes-Services verbinden eine Reihe von Pods mit einem abstrahierten Servicenamen und einer abstrahierten IP-Adresse. Services bieten Erkennung und Routing zwischen Pods. Beispielsweise verbinden Services das Frontend einer Anwendung mit ihrem Backend, von denen jedes in separaten Bereitstellungen in einem Cluster ausgeführt wird. Services verwenden Bezeichnungen und Selektoren, um Pods mit anderen Anwendungen abzugleichen. Die zentralen Attribute eines Kubernetes-Services sind

• ein Bezeichnungsselektor, der Pods sucht,
• die IP-Adresse von ClusterIP und die zugewiesene Portnummer,
• Portdefinitionen,
• die optionale Zuordnung eingehender Ports zu einem Zielport.

Services können ohne Pod-Selektoren definiert werden, z. B. um von einem Service auf einen anderen Service in einem anderen Namespace oder Cluster zu verweisen.

• ClusterIP: Stellt einen Service bereit, auf den nur innerhalb des Clusters zugegriffen werden kann.
• NodePort: Stellt einen Service über einen statischen Port an der IP-Adresse jedes Knotens bereit.
• LoadBalancer: Stellt den Service über den Lastausgleich des Cloud-Anbieters bereit.
• ExternalName: Ordnet einen Service einem vordefinierten externalName-Feld zu, indem ein Wert für den CNAME-Datensatz zurückgegeben wird.

Was ist der Kubernetes ClusterIP-Service?

ClusterIP ist der Standardservicetyp, mit dem ein Service an einer internen IP-Adresse des Clusters bereitgestellt wird. Zugriff ist nur innerhalb des Clusters zulässig.

Was ist ein Kubernetes Headless-Service?

Services, die keinen Lastausgleich benötigen und nur eine einzige IP-Adresse bereitstellen, können einen „Headless“-Service erstellen, indem „none“ als ClusterIP angegeben wird.

Headless-Services können mit Selektoren definiert werden. In diesem Fall werden Endpunktdatensätze in der API erstellt, die den DNS ändern, sodass Adressen zurückgegeben werden. Diese verweisen auf Pods, die den Service verfügbar machen. Headless-Services ohne Selektoren erstellen keine Endpunktdatensätze. Das DNS-System konfiguriert entweder den CNAME-Datensatz oder einen Datensatz für Endpunkte mit demselben Namen wie der Service.

Was ist ein Kubernetes NodePort-Service?

NodePorts sind offene Ports in jedem Cluster-Knoten. Kubernetes leitet Datenverkehr, der an einem NodePort ankommt, an den Service weiter, auch wenn der Service nicht in diesem Knoten ausgeführt wird. NodePort ist als Grundlage für andere übergeordnete Ingress-Methoden wie Lastausgleich gedacht und unterstützt die Entwicklung.

Was ist ein Kubernetes ExternalName-Service?

ExternalName-Services sind mit anderen Kubernetes-Services vergleichbar. Der Zugriff erfolgt jedoch nicht über eine ClusterIP-Adresse, sondern es wird ein CNAME-Datensatz mit einem Wert zurückgegeben, der beim Erstellen des Services im Parameter „externalName:“ festgelegt wurde.

Was ist ein Kubernetes LoadBalancer-Service?

Für Cluster, die bei Public-Cloud-Anbietern wie AWS oder Azure ausgeführt werden, entspricht das Erstellen eines LoadBalancer-Service einem ClusterIP-Service, der auf einen für den Cloud-Anbieter spezifischen externen Lastausgleich erweitert wird. Kubernetes erstellt automatisch den Lastausgleich, stellt bei Bedarf Firewall-Regeln bereit und gibt für den Service die vom Cloud-Anbieter zugewiesene externe IP-Adresse an.

Services verweisen einfach mithilfe von Bezeichnungen auf Pods. Da Services nicht knotenspezifisch sind, kann ein Service auf einen Pod verweisen, unabhängig davon, wo er zu einem bestimmten Zeitpunkt im Cluster ausgeführt wird. Durch Angabe einer Service-IP-Adresse sowie eines DNS-Servicenamens ist die Anwendung mit beiden Methoden erreichbar, solange der Service existiert.

Services werden wie alle Kubernetes-Objekte in YAML definiert. Angenommen, Sie haben Pods bereitgestellt, auf denen ein Backend-Service ausgeführt wird, um Daten von einem Web-Frontend zu verarbeiten. So würden Sie einen Service mit dem Namen „service-backend“ in der Bereitstellung „deployment-backend“ verfügbar machen:

apiVersion: v1

kind: Service

metadata:

name: service-backend

spec:

ports:

- port: 4000

protocol: TCP

targetPort: 333

selector:

run: deployment-backend

type: ClusterIP

Der Service „service-backend“ wird erstellt und jeder Pod im Cluster kann an seinem Port 333 über http://service-backend:4000 oder an der IP-Adresse des Clusters über Port 4000 darauf zugreifen.

Kubernetes-Services können auch mit dem Befehl „kubectl expose“ erstellt werden, für den keine YAML-Datei erforderlich ist. Derselbe Service kann mit dem folgenden Befehl erstellt werden:

kubectl expose deployment deployment-backend - - port=333- - target-port=4000 - - name=service-backend

Es gibt zwei Möglichkeiten, um einen Kubernetes-Service zu erkennen:

DNS (am gängigsten): Zum Erkennen von Services wird die DNS-Methode empfohlen. Bei dieser Methode muss zunächst ein DNS-Server im Cluster installiert werden. Der DNS-Server überwacht die Kubernetes-API. Beim Erstellen eines neuen Services steht sein Name zur einfachen Auflösung für anfordernde Anwendungen zur Verfügung.

ENV-Variable: Diese Methode basiert darauf, dass Kubelet jedem Knoten, auf dem ein Pod ausgeführt wird, Umgebungsvariablen für jeden aktiven Service hinzufügt.