Qu'est-ce que Kubernetes DaemonSet et comment l'utiliser ?

Présentation

Kubernetes vous permet d'automatiser le déploiement de logiciels, de gérer des applications conteneurisées et de faire évoluer vos clusters en toute simplicité. Un large éventail d'objets Kubernetes, y compris DaemonSets, offre un niveau de contrôle supplémentaire.

Utilisez les DaemonSets Kubernetes pour déployer des pods spécifiques sur chaque nœud de votre cluster.

Cet article explique ce qu'est un DaemonSet, quand l'utiliser et comment le créer.

Qu'est-ce qu'un DaemonSet Kubernetes ?

Kubernetes garantit qu'une application dispose de ressources suffisantes, s'exécute de manière fiable et maintient une haute disponibilité tout au long de son cycle de vie. L'emplacement de l'application au sein du cluster n'est pas une priorité.

Un DaemonSet vous permet de surmonter les limitations de planification de Kubernetes et garantit qu'une application spécifique est déployée sur tous les nœuds du cluster.m Les pods déployés contiennent généralement des processus d'arrière-plan qui doivent être diffusés dans l'ensemble du cluster.

Un DaemonSet est généralement décrit à l'aide d'un fichier YAML. Les champs du fichier YAML vous permettent de mieux contrôler le processus de déploiement du pod. Un bon exemple consiste à utiliser des étiquettes pour démarrer des pods spécifiques sur un sous-ensemble limité de nœuds.

Comment fonctionnent les DaemonSets ?

Un DaemonSet est un objet Kubernetes actif géré par un contrôleur. Vous pouvez déclarer l'état souhaité, en indiquant qu'un pod spécifique doit être présent sur chaque nœud. La boucle de contrôle de réconciliation va comparer l'état souhaité avec l'état observé courant. Si un nœud observé n'a pas de pod correspondant, le contrôleur DaemonSet va en créer un automatiquement.

Ce processus automatisé inclut les nœuds existants et tous les nœuds nouvellement créés. Les pods créés par les contrôleurs DaemonSet sont ignorés par le planificateur Kubernetes et existent aussi longtemps que le nœud lui-même.

Un DaemonSet crée un Pod sur chaque nœud par défaut. Si nécessaire, vous pouvez limiter le nombre de nœuds acceptables à l'aide d'un sélecteur de nœud. Le contrôleur DaemonSet va créer des pods uniquement sur les nœuds qui correspondent au nodeSelector prédéfini champ dans le fichier YAML.

Pourquoi utiliser un DaemonSet ?

Les DaemonSets peuvent améliorer les performances du cluster en déployant des pods qui effectuent des tâches de maintenance et des services de support sur chaque nœud. Des processus d'arrière-plan spécifiques, des applications de surveillance Kubernetes et d'autres agents doivent être présents dans l'ensemble du cluster pour fournir des services pertinents et opportuns.

Les DaemonSets sont exceptionnellement bien adaptés aux services de longue durée qui peuvent inclure :

• Collection de journaux
• Surveillance des ressources de nœud (frameworks tels que Prometheus)
• Stockage en cluster
• Pods liés à l'infrastructure (opérations système)

Il est courant qu'un DaemonSet déploie un type de démon sur tous les nœuds. Cependant, plusieurs DaemonSets peuvent également contrôler un type de démon en utilisant différentes étiquettes. Les libellés Kubernetes spécifient les règles de déploiement en fonction des caractéristiques des nœuds individuels.

Comment créer un DaemonSet ?

Vous pouvez décrire un DaemonSet dans un fichier YAML et appliquer le fichier au cluster à l'aide des commandes kubectl.

Par exemple, le daemonset-node-exporter.yaml le fichier ci-dessous déploie un exportateur de nœud Prometheus, dans le cadre du suivi espace de noms, pour surveiller les métriques d'utilisation du matériel sur chaque nœud du cluster.

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: /

Accédez à votre interface de ligne de commande Kubernetes et appliquez le fichier YAML nouvellement créé :

kubectl apply -f daemonset-node-exporter.yaml

Le système confirme que le DaemonSet a été créé.

Une fois que vous avez soumis le daemonset-node-exporter DaemonSet, confirmez son état actuel avec le describe commande :

kubectl describe daemonset node-exporter -n monitoring

La sortie offre des informations de base sur DaemonSet et indique que le pod a été déployé sur tous les nœuds disponibles.

Vous pouvez également le confirmer en répertoriant tous les pods en cours d'exécution avec la commande suivante :

kubectl get pod -o wide -n monitoring

Le DaemonSet va maintenant déployer en continu le node-exporter Pod à tous les nœuds nouvellement créés.

Comment limiter DaemonSet à des nœuds spécifiques

Les DaemonSets créent des pods sur chaque nœud du cluster par défaut, à moins que les sélecteurs de nœuds ne les contraignent. Au départ, il est nécessaire d'ajouter l'ensemble d'étiquettes souhaité à un sous-ensemble de nœuds.

Réalisez cela en utilisant le kubectl label commande. Ajoutez le ssd=true étiquette au node01 noeud avec la commande suivante :

kubectl label nodes node01 ssd=true

Les sélecteurs de nœud font partie du nodeSelector dans le fichier DaemonSet YAML. Dans l'exemple suivant, un DaemonSet va déployer Nginx uniquement sur des nœuds étiquetés comme ssd=true .

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

Ajout du ssd=true label à un nouveau nœud va déployer le nginx-ssd-storage Pod à ce nœud. Si une étiquette est supprimée d'un nœud, le contrôleur DaemonSet supprime également le pod.

Comment mettre à jour un DaemonSet ?

Le OnDelete La stratégie de mise à jour était le seul moyen de mettre à jour les pods gérés par un DaemonSet dans les premières versions de Kubernetes (avant la version 1.6). Un OnDelete approche nécessite que vous supprimiez chaque pod manuellement. Ce n'est qu'alors que le DaemonSet peut créer un nouveau pod en utilisant la nouvelle configuration.

Les versions récentes de Kubernetes utilisent les mises à jour progressives par défaut. La stratégie de mise à jour est définie à l'aide du spec.updateStrategy.type domaine. La valeur par défaut est définie sur RollingUpdate .

La stratégie de mise à jour progressive supprime les anciens pods et en crée de nouveaux à la place. Le processus est automatique et contrôlé. La suppression et la création de tous les pods en même temps peuvent entraîner une indisponibilité et des temps d'arrêt prolongés.

Deux paramètres vous permettent de contrôler le processus de mise à jour :

• minReadySeconds définit la période entre les mises à niveau du pod. La valeur est définie en secondes et la définition d'un délai raisonnable garantit la santé du pod avant que le système ne procède à la mise à jour du pod suivant.
• updateStrategy.rollingUpdate.maxUnavailable vous permet de définir le nombre de pods pouvant être mis à jour en même temps. La valeur de ce paramètre dépend fortement du type d'application déployée. Il est nécessaire d'équilibrer vitesse et sécurité pour garantir une haute disponibilité.

Utiliser le kubectl rollout commande pour vérifier l'état d'une mise à jour progressive de DaemonSet :

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

Le système observe les mises à jour de DaemonSet et vous informe de l'état actuel du déploiement du node-exporter DaemonSet.

Comment supprimer un DaemonSet ?

Supprimez un DaemonSet à l'aide de kubectl delete commande. Assurez-vous de bien spécifier le nom du DaemonSet que vous souhaitez supprimer :

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

Cette commande doit être utilisée avec précaution. La suppression d'un DaemonSet nettoie également tous les pods déployés par le DaemonSet en question.