Was ist Kubernetes DaemonSet und wie wird es verwendet?

Einführung

Mit Kubernetes können Sie die Softwarebereitstellung automatisieren, containerisierte Anwendungen verwalten und Ihre Cluster mühelos skalieren. Eine breite Palette von Kubernetes-Objekten, einschließlich DaemonSets, bietet eine zusätzliche Kontrollebene.

Verwenden Sie Kubernetes DaemonSets, um bestimmte Pods auf jedem einzelnen Knoten in Ihrem Cluster bereitzustellen.

Dieser Artikel erklärt, was ein DaemonSet ist, wann es verwendet wird und wie es erstellt wird.

Was ist ein Kubernetes DaemonSet?

Kubernetes stellt sicher, dass eine Anwendung über ausreichend Ressourcen verfügt, zuverlässig läuft und während ihres gesamten Lebenszyklus eine hohe Verfügbarkeit aufrechterhält. Der Standort der App innerhalb des Clusters hat keine Priorität.

Mit einem DaemonSet können Sie die Planungsbeschränkungen von Kubernetes überwinden und sicherstellen, dass eine bestimmte App auf allen Knoten innerhalb des Clusters bereitgestellt wird. m Die bereitgestellten Pods enthalten normalerweise Hintergrundprozesse, die im gesamten Cluster verteilt werden müssen.

Ein DaemonSet wird normalerweise mit einer YAML-Datei beschrieben. Die Felder in der YAML-Datei geben Ihnen zusätzliche Kontrolle über den Pod-Bereitstellungsprozess. Ein gutes Beispiel ist die Verwendung von Labels, um bestimmte Pods auf einer begrenzten Teilmenge von Knoten zu starten.

Wie funktionieren DaemonSets?

Ein DaemonSet ist ein aktives Kubernetes-Objekt, das von einem Controller verwaltet wird. Sie können Ihren gewünschten Zustand angeben, der angibt, dass ein bestimmter Pod auf jedem Knoten vorhanden sein muss. Die Abstimmungsregelschleife vergleicht den gewünschten Zustand mit dem aktuell beobachteten Zustand. Wenn ein beobachteter Knoten keinen passenden Pod hat, erstellt der DaemonSet-Controller automatisch einen.

Dieser automatisierte Prozess umfasst vorhandene Knoten und alle neu erstellten Knoten. Die von DaemonSet-Controllern erstellten Pods werden vom Kubernetes-Scheduler ignoriert und existieren so lange wie der Knoten selbst.

Ein DaemonSet erstellt standardmäßig einen Pod auf jedem Knoten. Bei Bedarf können Sie die Anzahl der akzeptablen Knoten mithilfe eines Knotenselektors einschränken. Der DaemonSet-Controller erstellt Pods nur auf Knoten, die mit dem vordefinierten nodeSelector übereinstimmen Feld in der YAML-Datei.

Warum ein DaemonSet verwenden?

DaemonSets können die Clusterleistung verbessern, indem Pods bereitgestellt werden, die Wartungsaufgaben und Supportdienste für jeden Knoten ausführen. Spezifische Hintergrundprozesse, Kubernetes-Überwachungs-Apps und andere Agenten müssen im gesamten Cluster vorhanden sein, um relevante und zeitnahe Dienste bereitzustellen.

DaemonSets eignen sich besonders gut für lang andauernde Dienste, die Folgendes beinhalten können:

• Protokollsammlung
• Knotenressourcenüberwachung (Frameworks wie Prometheus)
• Cluster-Speicher
• Infrastrukturbezogene Pods (Systembetrieb)

Es ist üblich, dass ein DaemonSet einen Daemon-Typ auf allen Knoten bereitstellt. Mehrere DaemonSets können jedoch auch einen Daemon-Typ steuern, indem sie unterschiedliche Labels verwenden. Kubernetes-Labels geben Bereitstellungsregeln basierend auf den Merkmalen einzelner Knoten an.

Wie erstelle ich ein DaemonSet?

Sie können ein DaemonSet in einer YAML-Datei beschreiben und die Datei mit den kubectl-Befehlen auf den Cluster anwenden.

Beispiel:daemonset-node-exporter.yaml Die folgende Datei stellt einen Prometheus-Knoten-Exporter bereit innerhalb der Überwachung Namespace, um Hardwarenutzungsmetriken auf jedem Knoten im Cluster zu überwachen.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-exporter
  namespace: monitoring
  labels:
    name: node-exporter
spec:
  template:
    metadata:
      labels:
        name: node-exporter
      annotations:
         prometheus.io/scrape: "true"
         prometheus.io/port: "9100"
    spec:
      hostPID: true
      hostIPC: true
      hostNetwork: true
      containers:
        - ports:
            - containerPort: 9100
              protocol: TCP
          resources:
            requests:
              cpu: 0.15
          securityContext:
            privileged: true
          image: prom/node-exporter:v0.15.2
          args:
            - --path.procfs
            - /host/proc
            - --path.sysfs
            - /host/sys
            - --collector.filesystem.ignored-mount-points
            - '"^/(sys|proc|dev|host|etc)($|/)"'
          name: node-exporter
          volumeMounts:
            - name: dev
              mountPath: /host/dev
            - name: proc
              mountPath: /host/proc
            - name: sys
              mountPath: /host/sys
            - name: rootfs
              mountPath: /rootfs
      volumes:
        - name: proc
          hostPath:
            path: /proc
        - name: dev
          hostPath:
            path: /dev
        - name: sys
          hostPath:
            path: /sys
        - name: rootfs
          hostPath:
            path: /

Greifen Sie auf Ihre Kubernetes-Befehlszeilenschnittstelle zu und wenden Sie die neu erstellte YAML-Datei an:

kubectl apply -f daemonset-node-exporter.yaml

Das System bestätigt, dass das DaemonSet erstellt wurde.

Nachdem Sie den daemonset-node-exporter übermittelt haben DaemonSet, bestätigen Sie seinen aktuellen Zustand mit describe Befehl:

kubectl describe daemonset node-exporter -n monitoring

Die Ausgabe bietet grundlegende DaemonSet-Informationen und zeigt an, dass der Pod auf allen verfügbaren Knoten bereitgestellt wurde.

Sie können dies zusätzlich bestätigen, indem Sie alle laufenden Pods mit dem folgenden Befehl auflisten:

kubectl get pod -o wide -n monitoring

Das DaemonSet wird nun kontinuierlich den node-exporter bereitstellen Pod zu allen neu erstellten Knoten.

DaemonSet auf bestimmte Knoten beschränken

DaemonSets erstellen standardmäßig Pods auf jedem Knoten im Cluster, es sei denn, Knotenselektoren beschränken sie. Zunächst ist es notwendig, den gewünschten Satz von Labels zu einer Teilmenge von Knoten hinzuzufügen.

Erreichen Sie dies, indem Sie das kubectl label verwenden Befehl. Fügen Sie ssd=true hinzu Label zum node01 Knoten mit dem folgenden Befehl:

kubectl label nodes node01 ssd=true

Knotenselektoren sind Teil von nodeSelector -Feld in der DaemonSet-YAML-Datei. Im folgenden Beispiel stellt ein DaemonSet Nginx nur auf Knoten bereit, die als ssd=true gekennzeichnet sind .

apiVersion: apps/v1 
kind: "DaemonSet" 
metadata: 
labels: 
app: nginx 
ssd: "true" 
name: nginx-ssd-storage 
spec: 
template: 
metadata: 
labels: 
app: nginx ssd: "true" 
spec: 
nodeSelector: 
ssd: "true" 
containers: - 
name: nginx 
image: nginx:1.10.0

Hinzufügen von ssd=true label zu einem neuen Knoten wird der nginx-ssd-storage bereitgestellt Pod zu diesem Knoten. Wenn ein Label von einem Knoten entfernt wird, entfernt der DaemonSet-Controller auch den Pod.

Wie aktualisiere ich ein DaemonSet?

Die OnDelete Die Update-Strategie war die einzige Möglichkeit, Pods zu aktualisieren, die in frühen Kubernetes-Versionen (vor Version 1.6) von einem DaemonSet verwaltet wurden. Ein OnDelete Ansatz erfordert, dass Sie jeden Pod manuell löschen. Nur dann ist das DaemonSet in der Lage, einen neuen Pod mit der neuen Konfiguration zu erstellen.

Neuere Kubernetes-Versionen verwenden standardmäßig fortlaufende Updates. Die Aktualisierungsstrategie wird mithilfe von spec.updateStrategy.type definiert Feld. Der Standardwert ist auf RollingUpdate festgelegt .

Die fortlaufende Update-Strategie entfernt alte Pods und erstellt stattdessen neue. Der Prozess ist automatisch und kontrolliert. Das gleichzeitige Löschen und Erstellen aller Pods kann zu Nichtverfügbarkeit und längeren Ausfallzeiten führen.

Mit zwei Parametern können Sie den Update-Vorgang steuern:

• minReadySeconds definiert den Zeitraum zwischen Pod-Upgrades. Der Wert wird in Sekunden definiert, und das Festlegen eines angemessenen Zeitrahmens sichert den Zustand des Pods, bevor das System mit der Aktualisierung des nächsten Pods fortfährt.
• updateStrategy.rollingUpdate.maxUnavailable können Sie die Anzahl der Pods definieren, die gleichzeitig aktualisiert werden können. Der Wert dieses Parameters hängt stark von der Art der bereitgestellten Anwendung ab. Es ist notwendig, Geschwindigkeit und Sicherheit in Einklang zu bringen, um eine hohe Verfügbarkeit zu gewährleisten.

Verwenden Sie das kubectl rollout Befehl, um den Status eines fortlaufenden DaemonSet-Upgrades zu überprüfen:

kubectl rollout status ds/daemonset-node-exporter -n monitoring

Das System beobachtet DaemonSet-Updates und informiert Sie über den aktuellen Rollout-Status des node-exporter DaemonSet.

Wie lösche ich ein DaemonSet?

Entfernen Sie ein DaemonSet mit kubectl delete Befehl. Achten Sie darauf, den Namen des DaemonSets, das Sie löschen möchten, korrekt anzugeben:

kubectl delete -f daemonset-node-exporter.yaml -n monitoring

Dieser Befehl sollte mit Vorsicht verwendet werden. Durch das Löschen eines DaemonSets werden auch alle Pods bereinigt, die das betreffende DaemonSet bereitgestellt hat.