Some workloads need to run on every node (or every node matching a selector) — not scaled by replica count, but by node count. Log collectors, monitoring agents, network plugins, storage drivers — these are DaemonSet territory.

1. What a DaemonSet Does

A DaemonSet ensures that exactly one Pod runs on each eligible node. When a node joins the cluster, the DaemonSet automatically schedules a Pod on it. When a node is removed, the Pod is garbage-collected.

Common DaemonSet Use Cases

DaemonSet Manifest

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd
  namespace: kube-system
spec:
  selector:
    matchLabels:
      app: fluentd
  template:
    metadata:
      labels:
        app: fluentd
    spec:
      containers:
        - name: fluentd
          image: fluent/fluentd:v1.16
          resources:
            requests:
              cpu: 100m
              memory: 200Mi
            limits:
              memory: 500Mi
          volumeMounts:
            - name: varlog
              mountPath: /var/log
            - name: containers
              mountPath: /var/lib/docker/containers
              readOnly: true
      volumes:
        - name: varlog
          hostPath:
            path: /var/log
        - name: containers
          hostPath:
            path: /var/lib/docker/containers

2. Controlling Which Nodes Get a Pod

nodeSelector — Simple Label Matching

# Only schedule on nodes with label "disk=ssd":
spec:
  template:
    spec:
      nodeSelector:
        disk: ssd

nodeAffinity — Advanced Rules

# Only schedule on nodes in specific zones:
spec:
  template:
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: topology.kubernetes.io/zone
                    operator: In
                    values: [us-east-1a, us-east-1b]

Tolerations — Running on Control Plane Nodes

Control plane nodes have taints that prevent scheduling. To run a DaemonSet on them (e.g., for monitoring), add tolerations:

# Tolerate control plane taint:
spec:
  template:
    spec:
      tolerations:
        - key: node-role.kubernetes.io/control-plane
          operator: Exists
          effect: NoSchedule
        # For older clusters:
        - key: node-role.kubernetes.io/master
          operator: Exists
          effect: NoSchedule

# Tolerate ALL taints (run on every node no matter what):
      tolerations:
        - operator: Exists    # matches any key, any value, any effect

3. Update Strategies

RollingUpdate Parameters

spec:
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1        # How many nodes can lose their DS Pod at once
      maxSurge: 0              # (K8s 1.22+) Extra Pods allowed during update

Checking Rollout Status

# Watch DaemonSet rollout:
kubectl rollout status daemonset/fluentd -n kube-system

# See current state:
kubectl get ds fluentd -n kube-system
# NAME      DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   AGE
# fluentd   3         3         3       3            3           5d

# DESIRED = number of eligible nodes
# UP-TO-DATE = Pods running latest template
# If UP-TO-DATE < DESIRED, rollout is in progress

4. Practical Patterns

Host-Level Access

DaemonSet Pods often need access to the host's filesystem, network, or devices:

spec:
  template:
    spec:
      # Use host network (share the node's IP):
      hostNetwork: true
      
      # Use host PID namespace (see all processes on node):
      hostPID: true
      
      # Mount host directories:
      volumes:
        - name: host-root
          hostPath:
            path: /
        - name: host-proc
          hostPath:
            path: /proc
      
      # Required for some agents (e.g., Falco needs kernel access):
      containers:
        - name: agent
          securityContext:
            privileged: true       # ⚠️ Use only when necessary

Resource Reservation

DaemonSet Pods consume resources on every node. Plan for this:

# If your DS requests 200Mi memory on each node,
# and you have 100 nodes, that's 20Gi of memory reserved cluster-wide.
# This reduces allocatable capacity for other workloads.

# Check DS resource footprint:
kubectl get ds -A -o custom-columns=\
NAME:.metadata.name,\
NS:.metadata.namespace,\
CPU_REQ:.spec.template.spec.containers[0].resources.requests.cpu,\
MEM_REQ:.spec.template.spec.containers[0].resources.requests.memory

DaemonSet vs Static Pods

5. DaemonSet vs Deployment: When Which?

Summary