Saltar al contenido principal

Lab 7.2 - DaemonSet para Monitoring

Objetivos del Lab​

Al final de este laboratorio, usted será capaz de:

  • Comprender el concepto de DaemonSet.
  • Crear un DaemonSet para desplegar un agente de monitoreo.
  • Verificar que el DaemonSet se ejecuta en todos los nodos.
  • Comprender los casos de uso de los DaemonSets.
  • Gestionar los DaemonSets (actualización, eliminación).

Duración Estimada​

45-60 minutos

Requisitos Previos​

  • kubectl instalado y configurado.
  • Cluster Kubernetes local funcional (minikube o kind).
  • Conocimientos sobre los DaemonSets (Capítulo 7.2).

Parte 1: Comprender los DaemonSets​

Un DaemonSet garantiza que una copia de un Pod se ejecute en cada nodo (o en un subconjunto de nodos). Es ideal para:

  • Agentes de monitoreo (ej: node-exporter)
  • Agentes de logging (ej: Fluentd, Fluent Bit)
  • Agentes de seguridad
  • Coleccionistas de métricas

Paso 1.1: Verificar los Nodos​

Verifique los nodos de su cluster:

kubectl get nodes

Para un cluster local (minikube/kind), generalmente tendrá un solo nodo.

Parte 2: Creación de un DaemonSet Simple​

Vamos a crear un DaemonSet que simula un agente de monitoreo simple.

Paso 2.1: Crear el DaemonSet​

Cree un archivo 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

Explicación:

  • El DaemonSet crea un Pod en cada nodo.
  • El contenedor monta /proc y /sys del nodo para acceder a las métricas del sistema.
  • El contenedor muestra periódicamente información sobre el nodo.

Aplique el DaemonSet:

kubectl apply -f daemonset-monitoring.yaml

Parte 3: Verificación del DaemonSet​

Paso 3.1: Verificar los Pods Creados​

Verifique que los Pods han sido creados:

kubectl get pods -l app=node-monitor

Debería ver un Pod por nodo. Para un cluster con un solo nodo, verá un Pod.

Verifique en qué nodos se están ejecutando los Pods:

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

Paso 3.2: Verificar el Estado del DaemonSet​

Verifique el estado del DaemonSet:

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

Debería ver:

  • DESIRED: Número de nodos donde el Pod debería ejecutarse
  • CURRENT: Número de Pods actualmente creados
  • READY: Número de Pods listos
  • UP-TO-DATE: Número de Pods actualizados con la plantilla
  • AVAILABLE: Número de Pods disponibles

Paso 3.3: Verificar los Logs​

Verifique los logs de un Pod para ver las métricas recolectadas:

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

Debería ver mensajes periódicos con la información del nodo.

Parte 4: Prueba de Adición de Nodo (Simulación)​

Si tuviera varios nodos, el DaemonSet crearía automáticamente un Pod en cada nuevo nodo. Para un cluster local, vamos a simular esto verificando el comportamiento.

Paso 4.1: Verificar el Comportamiento​

El DaemonSet monitorea automáticamente los nodos. Si se añade un nuevo nodo al cluster, un Pod será creado automáticamente en ese nodo.

Verifique la descripción del DaemonSet para ver los detalles:

kubectl describe daemonset node-monitor

Parte 5: Actualización del DaemonSet​

Paso 5.1: Actualizar la Imagen​

Modifique el DaemonSet para cambiar la frecuencia de recolección:

# 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 activo"
            sleep 10 # Cambiado de 30 a 10 segundos
          done
        resources:
          requests:
            cpu: 100m
            memory: 64Mi
          limits:
            cpu: 200m
            memory: 128Mi

Aplique la actualización:

kubectl apply -f daemonset-monitoring-updated.yaml

Paso 5.2: Observar la Actualización​

Los Pods del DaemonSet se actualizan de manera rolling (uno por uno):

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

Verá los Pods antiguos ser eliminados y los nuevos ser creados.

Verifique los nuevos logs:

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

Debería ver los mensajes con "[UPDATED]" y una frecuencia más alta.

Parte 6: Node Selectors y Taints​

Paso 6.1: Usar un Node Selector (Opcional)​

Puede limitar los nodos donde el DaemonSet se ejecuta con un nodeSelector:

spec:
  template:
    spec:
      nodeSelector:
        kubernetes.io/os: linux # Se ejecuta solo en nodos Linux
      containers:
      # ...

Paso 6.2: Tolerar los Taints (Opcional)​

Si algunos nodos tienen taints, puede agregar tolerations al DaemonSet:

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

Parte 7: Limpieza​

Elimine el DaemonSet:

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

Todos los Pods creados por el DaemonSet serán eliminados automáticamente.

Resumen del Lab​

En este laboratorio, usted ha explorado los DaemonSets para el monitoreo. Aprendió a crear un DaemonSet que se ejecuta en todos los nodos, a verificar su comportamiento, a actualizarlo y a comprender los casos de uso típicos (monitoreo, logging, seguridad).

Próximos Pasos​

El próximo laboratorio le mostrará cómo utilizar los Jobs y CronJobs para ejecutar tareas puntuales y programadas.

Lab 7.3: Jobs y CronJobs

Lab creado el: Diciembre 2024