Aller au contenu principal

Lab 7.2 - DaemonSet pour Monitoring

Objectifs du Lab​

À la fin de ce lab, vous serez capable de:

  • Comprendre le concept de DaemonSet.
  • Créer un DaemonSet pour déployer un agent de monitoring.
  • Vérifier que le DaemonSet s'exécute sur tous les nœuds.
  • Comprendre les cas d'usage des DaemonSets.
  • Gérer les DaemonSets (mise à jour, suppression).

Durée Estimée​

45-60 minutes

Prérequis​

  • kubectl installé et configuré.
  • Cluster Kubernetes local fonctionnel (minikube ou kind).
  • Connaissances sur les DaemonSets (Chapitre 7.2).

Partie 1: Comprendre les DaemonSets​

Un DaemonSet garantit qu'une copie d'un Pod s'exécute sur chaque nœud (ou sur un sous-ensemble de nœuds). C'est idéal pour:

  • Agents de monitoring (ex: node-exporter)
  • Agents de logging (ex: Fluentd, Fluent Bit)
  • Agents de sécurité
  • Collecteurs de métriques

Étape 1.1: Vérifier les Nœuds​

Vérifiez les nœuds de votre cluster:

kubectl get nodes

Pour un cluster local (minikube/kind), vous aurez généralement un seul nœud.

Partie 2: Création d'un DaemonSet Simple​

Nous allons créer un DaemonSet qui simule un agent de monitoring simple.

Étape 2.1: Créer le DaemonSet​

Créez un fichier daemonset-monitoring.yaml:

# daemonset-monitoring.yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-monitor
  labels:
    app: node-monitor
spec:
  selector:
    matchLabels:
      app: node-monitor
  template:
    metadata:
      labels:
        app: node-monitor
    spec:
      containers:
      - name: monitor-agent
        image: busybox:1.35
        command: ["/bin/sh", "-c"]
        args:
        - |
          while true; do
            echo "$(date): Node $(hostname) - CPU: $(cat /proc/loadavg | awk '{print $1}') - Memory: $(free -m | grep Mem | awk '{print $3}')MB used"
            sleep 30
          done
        resources:
          requests:
            cpu: 100m
            memory: 64Mi
          limits:
            cpu: 200m
            memory: 128Mi
        volumeMounts:
        - name: proc
          mountPath: /proc
          readOnly: true
        - name: sys
          mountPath: /sys
          readOnly: true
      volumes:
      - name: proc
        hostPath:
          path: /proc
      - name: sys
        hostPath:
          path: /sys

Explication:

  • Le DaemonSet crée un Pod sur chaque nœud.
  • Le conteneur monte /proc et /sys du nœud pour accéder aux métriques système.
  • Le conteneur affiche périodiquement des informations sur le nœud.

Appliquez le DaemonSet:

kubectl apply -f daemonset-monitoring.yaml

Partie 3: Vérification du DaemonSet​

Étape 3.1: Vérifier les Pods Créés​

Vérifiez que les Pods sont créés:

kubectl get pods -l app=node-monitor

Vous devriez voir un Pod par nœud. Pour un cluster avec un seul nœud, vous verrez un Pod.

Vérifiez sur quels nœuds les Pods s'exécutent:

kubectl get pods -l app=node-monitor -o wide

Étape 3.2: Vérifier le Statut du DaemonSet​

Vérifiez le statut du DaemonSet:

kubectl get daemonset node-monitor
# ou
kubectl get ds node-monitor

Vous devriez voir:

  • DESIRED: Nombre de nœuds où le Pod devrait s'exécuter
  • CURRENT: Nombre de Pods actuellement créés
  • READY: Nombre de Pods prêts
  • UP-TO-DATE: Nombre de Pods à jour avec le template
  • AVAILABLE: Nombre de Pods disponibles

Étape 3.3: Vérifier les Logs​

Vérifiez les logs d'un Pod pour voir les métriques collectées:

kubectl logs -l app=node-monitor --tail=10

Vous devriez voir des messages périodiques avec les informations du nœud.

Partie 4: Test d'Ajout de Nœud (Simulation)​

Si vous aviez plusieurs nœuds, le DaemonSet créerait automatiquement un Pod sur chaque nouveau nœud. Pour un cluster local, nous allons simuler cela en vérifiant le comportement.

Étape 4.1: Vérifier le Comportement​

Le DaemonSet surveille automatiquement les nœuds. Si un nouveau nœud est ajouté au cluster, un Pod sera automatiquement créé sur ce nœud.

Vérifiez la description du DaemonSet pour voir les détails:

kubectl describe daemonset node-monitor

Partie 5: Mise à Jour du DaemonSet​

Étape 5.1: Mettre à Jour l'Image​

Modifiez le DaemonSet pour changer la fréquence de collecte:

# daemonset-monitoring-updated.yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-monitor
  labels:
    app: node-monitor
spec:
  selector:
    matchLabels:
      app: node-monitor
  template:
    metadata:
      labels:
        app: node-monitor
    spec:
      containers:
      - name: monitor-agent
        image: busybox:1.35
        command: ["/bin/sh", "-c"]
        args:
        - |
          while true; do
            echo "$(date): [UPDATED] Node $(hostname) - Monitoring actif"
            sleep 10 # Changé de 30 à 10 secondes
          done
        resources:
          requests:
            cpu: 100m
            memory: 64Mi
          limits:
            cpu: 200m
            memory: 128Mi

Appliquez la mise à jour:

kubectl apply -f daemonset-monitoring-updated.yaml

Étape 5.2: Observer la Mise à Jour​

Les Pods du DaemonSet sont mis à jour de manière rolling (un par un):

kubectl get pods -l app=node-monitor -w

Vous verrez les anciens Pods être supprimés et les nouveaux être créés.

Vérifiez les nouveaux logs:

kubectl logs -l app=node-monitor --tail=5

Vous devriez voir les messages avec "[UPDATED]" et une fréquence plus élevée.

Partie 6: Node Selectors et Taints​

Étape 6.1: Utiliser un Node Selector (Optionnel)​

Vous pouvez limiter les nœuds où le DaemonSet s'exécute avec un nodeSelector:

spec:
  template:
    spec:
      nodeSelector:
        kubernetes.io/os: linux # S'exécute uniquement sur les nœuds Linux
      containers:
      # ...

Étape 6.2: Tolérer les Taints (Optionnel)​

Si certains nœuds ont des taints, vous pouvez ajouter des tolerations au DaemonSet:

spec:
  template:
    spec:
      tolerations:
      - key: "node-role.kubernetes.io/master"
        operator: "Exists"
        effect: "NoSchedule"
      containers:
      # ...

Partie 7: Nettoyage​

Supprimez le DaemonSet:

kubectl delete daemonset node-monitor
# ou
kubectl delete -f daemonset-monitoring.yaml

Tous les Pods créés par le DaemonSet seront automatiquement supprimés.

Résumé du Lab​

Dans ce lab, vous avez exploré les DaemonSets pour le monitoring. Vous avez appris à créer un DaemonSet qui s'exécute sur tous les nœuds, à vérifier son comportement, à le mettre à jour, et à comprendre les cas d'usage typiques (monitoring, logging, sécurité).

Prochaines Étapes​

Le prochain lab vous montrera comment utiliser les Jobs et CronJobs pour exécuter des tâches ponctuelles et planifiées.

Lab 7.3: Jobs et CronJobs

Lab créé le: Décembre 2024