23 Selektoren

Selectors in Kubernetes sind eine Methode, um Ressourcen wie Pods oder Nodes anhand ihrer Labels zu filtern und auszuwählen. Sie ermöglichen es Nutzern und Systemkomponenten, Ressourcen basierend auf Label-Schlüssel-Wert-Paaren zu identifizieren und zu gruppieren.

Selektoren können sowohl über die Kommandozeilenschnittstelle (CLI) als auch in den Manifest-Dateien von Kubernetes eingesetzt werden. Diese Dualität ermöglicht es Operatoren und Entwicklern, Ressourcen dynamisch während der Laufzeit zu verwalten oder feste Selektionskriterien innerhalb der Deklarationen von Ressourcen zu definieren.

In der CLI können Selektoren benutzt werden, um Ressourcen in Echtzeit zu filtern und zu managen. Beispielsweise ermöglicht der Befehl kubectl get pods -l app=frontend das Abrufen aller Pods, die mit dem Label app=frontend versehen sind. Dies ist besonders nützlich für Ad-hoc-Abfragen und für die Skriptautomatisierung.

In den Manifesten definiert man Selektoren, um die Beziehungen zwischen Ressourcen festzulegen. Ein Deployment-Spec könnte beispielsweise einen Selektor matchLabels enthalten, der definiert, welche Pods als Replikas für dieses Deployment betrachtet werden sollen. Durch das Festlegen von Selektoren in Manifesten stellt man sicher, dass die Beziehungen und Abhängigkeiten zwischen Ressourcen erhalten bleiben, auch wenn sie dynamisch skaliert oder modifiziert werden.

Die Verwendung von Selektoren in Manifesten fördert zudem die deklarative Konfiguration von Ressourcen, die es ermöglicht, den gewünschten Zustand des Systems zu beschreiben, während Kubernetes die Verantwortung für das Erreichen und Aufrechterhalten dieses Zustands übernimmt.

23.1 Arten von Selectors

Es gibt zwei Haupttypen von Selectors in Kubernetes:

  1. Equality-based selectors erlauben die Auswahl von Ressourcen, die genau die angegebene Label-Kombination haben.
  2. Set-based selectors erlauben eine Auswahl basierend auf Label-Werten, die in einer Menge definiert sind.

23.2 Beispiel

Nehmen wir an, Sie betreiben eine Reihe von Pods, die verschiedene Komponenten Ihrer Anwendung in einer Entwicklungs- und Produktionsumgebung repräsentieren. Jeder Pod könnte Labels haben, die seine Rolle (role) und die Umgebung (env) angeben, in der er läuft.

Hier ist ein Beispiel, wie Pods mit bestimmten Labels ausgewählt werden könnten:

  1. Equality-based Selector:

    Angenommen, Sie möchten alle Pods auswählen, die in der Produktionsumgebung laufen. Der entsprechende Befehl mit einem Equality-based Selector könnte sein:

    kubectl get pods -l env=prod

  2. Set-based Selector:

    Wenn Sie Pods auswählen möchten, die entweder als Frontend oder als Backend in der Entwicklungsumgebung gekennzeichnet sind, könnten Sie einen Set-based Selector verwenden:

    kubectl get pods -l 'env in (dev),role in (frontend,backend)'

23.3 Selector types

In Kubernetes-Manifesten werden verschiedene Arten von Selektoren verwendet, um Ressourcen basierend auf Labels zu identifizieren und zu gruppieren. Hier sind die häufig verwendeten Selektoren in Kubernetes-Manifesten:

23.4 Service Selector

Ein Service verwendet einen selector, um die Pods zu identifizieren, die den durch den Service definierten Satz von Netzwerkregeln verwenden. Ein Service-Selector wählt alle Pods aus, deren Labels mit den im Selector spezifizierten Labels übereinstimmen.

kind: Service
apiVersion: v1
metadata:
  name: frontend-service
spec:
  selector:
    app: frontend
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

23.5 Deployment, StatefulSet, Job matchLabels

Deployments, StatefulSets und Jobs verwenden matchLabels innerhalb der selector Spezifikation, um zu definieren, welche Pods zu der Ressource gehören.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: backend-container
        image: backend-image

23.6 Pod nodeSelector

Pods können einen nodeSelector verwenden, um einen bestimmten Knoten oder eine Gruppe von Knoten auszuwählen, auf denen der Pod geplant werden soll. Dies basiert auf den Labels, die den Knoten zugewiesen sind.

apiVersion: v1
kind: Pod
metadata:
  name: database-pod
spec:
  nodeSelector:
    disktype: ssd
  containers:
  - name: db-container
    image: mysql

In jedem dieser Beispiele ordnen die Selektoren Ressourcen basierend auf Label-Schlüssel-Wert-Paaren zu, um sicherzustellen, dass die Ressourcen gemäß den definierten Anforderungen und Affinitäten korrekt organisiert und geplant werden.

23.7 Praktisches Beispiel

Sie haben ein Deployment für ein Backend und ein Frontend, wobei jedes eine Version für die Entwicklungs- und die Produktionsumgebung hat.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend-dev
spec:
  selector:
    matchLabels:
      role: backend
      env: dev
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend-prod
spec:
  selector:
    matchLabels:
      role: frontend
      env: prod

Sie könnten alle Entwicklungspods mit dem Selector env=dev auswählen oder spezifisch das Backend in der Entwicklungsphase mit role=backend,env=dev.

Selectors ermöglichen eine mächtige und flexible Verwaltung der Ressourcen in einem Kubernetes-Cluster und sind essentiell für das tägliche Operieren, sei es für das Deployment, die Wartung oder die Skalierung von Anwendungen.