Pular para o conteúdo principal

Capítulo 7.2 - DaemonSets

Objetivos de Aprendizagem​

Ao final deste capítulo, você será capaz de:

  • Entender o que é um DaemonSet
  • Fazer o deploy de DaemonSets
  • Utilizar node selectors e affinities
  • Gerenciar DaemonSets com atualizações de nodes
  • Compreender os casos de uso típicos
  • Configurar DaemonSets para nodes específicos

Introdução​

Um DaemonSet garante que um Pod seja executado em todos (ou em alguns) nodes do cluster. Diferente dos Deployments, que gerenciam um número específico de Pods, os DaemonSets criam um Pod por node.

O que é um DaemonSet?​

Um DaemonSet garante que uma cópia de um Pod seja executada em cada node (ou em nodes selecionados) do cluster.

Características​

  • Um Pod por node: Implantado automaticamente em cada node
  • Auto-gerenciamento: Cria/remove Pods quando nodes são adicionados/removidos
  • Node-specific: Pode direcionar nodes específicos com selectors
  • System-level: Ideal para serviços de sistema

Casos de Uso Típicos​

1. Agentes de Logging​

Coletar logs de todos os nodes:

2. Agentes de Monitoramento​

Coletar métricas de todos os nodes:

  • Prometheus Node Exporter
  • Datadog Agent
  • New Relic Agent

3. Agentes de Segurança​

  • Antivirus
  • Intrusion Detection
  • Compliance scanners

4. Rede​

  • kube-proxy (já é um DaemonSet no Kubernetes)
  • Plugins CNI
  • Aplicação de network policies

5. Armazenamento​

  • Storage drivers
  • Plugins de volume

Exemplo: Fluentd para Logging​

DaemonSet Fluentd​

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd
  namespace: kube-system
spec:
  selector:
    matchLabels:
      name: fluentd
  template:
    metadata:
      labels:
        name: fluentd
    spec:
      tolerations:
      - key: node-role.kubernetes.io/master
        effect: NoSchedule
      containers:
      - name: fluentd
        image: fluent/fluentd-kubernetes-daemonset:v1-debian-elasticsearch
        env:
        - name: FLUENT_ELASTICSEARCH_HOST
          value: "elasticsearch.logging.svc.cluster.local"
        - name: FLUENT_ELASTICSEARCH_PORT
          value: "9200"
        resources:
          limits:
            memory: 200Mi
          requests:
            cpu: 100m
            memory: 200Mi
        volumeMounts:
        - name: varlog
          mountPath: /var/log
        - name: varlibdockercontainers
          mountPath: /var/lib/docker/containers
          readOnly: true
      terminationGracePeriodSeconds: 30
      volumes:
      - name: varlog
        hostPath:
          path: /var/log
      - name: varlibdockercontainers
        hostPath:
          path: /var/lib/docker/containers

Node Selectors​

Fazer o deploy apenas em alguns nodes:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: monitoring-agent
spec:
  template:
    spec:
      nodeSelector:
        monitoring: "enabled"
      containers:
      - name: agent
        image: monitoring-agent:1.0

Resultado: O DaemonSet cria Pods apenas nos nodes com o label monitoring=enabled.

Node Affinities​

Controle mais avançado com affinities:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: gpu-monitor
spec:
  template:
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: accelerator
                operator: In
                values:
                - nvidia-tesla-k80
                - nvidia-tesla-v100
      containers:
      - name: gpu-monitor
        image: gpu-monitor:1.0

Tolerations​

Os DaemonSets podem tolerar taints para rodar em nodes tainted:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: system-monitor
spec:
  template:
    spec:
      tolerations:
      - key: node-role.kubernetes.io/master
        operator: Exists
        effect: NoSchedule
      - key: node-role.kubernetes.io/control-plane
        operator: Exists
        effect: NoSchedule
      containers:
      - name: monitor
        image: system-monitor:1.0

Resultado: O DaemonSet também roda nos nodes master/control-plane.

Exemplo: Prometheus Node Exporter​

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-exporter
  namespace: monitoring
spec:
  selector:
    matchLabels:
      app: node-exporter
  template:
    metadata:
      labels:
        app: node-exporter
    spec:
      hostNetwork: true
      hostPID: true
      containers:
      - name: node-exporter
        image: prom/node-exporter:v1.5.0
        args:
        - --path.procfs=/host/proc
        - --path.sysfs=/host/sys
        - --collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($|/)
        volumeMounts:
        - name: proc
          mountPath: /host/proc
          readOnly: true
        - name: sys
          mountPath: /host/sys
          readOnly: true
      volumes:
      - name: proc
        hostPath:
          path: /proc
      - name: sys
        hostPath:
          path: /sys

Atualizações​

Rolling Update (Padrão)​

spec:
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1

Processo: Atualização progressiva dos Pods em cada node.

OnDelete​

spec:
  updateStrategy:
    type: OnDelete

Processo: Atualização apenas quando um Pod é removido manualmente.

Comandos Úteis​

Gerenciamento​

# Ver DaemonSets
kubectl get daemonset
kubectl get ds

# Detalhes
kubectl describe daemonset fluentd

# Ver Pods
kubectl get pods -l name=fluentd

# Logs
kubectl logs -l name=fluentd

Atualizações​

# Atualizar a imagem
kubectl set image daemonset/fluentd fluentd=fluent/fluentd:v2

# Ver status
kubectl rollout status daemonset/fluentd

# Rollback
kubectl rollout undo daemonset/fluentd

Diferenças: DaemonSet vs Deployment​

CaracterísticaDeploymentDaemonSet
Número de PodsEspecificado (replicas)Um por node
PlacementAleatórioEm cada node
Casos de usoAplicaçõesServiços de sistema
ScalingManualAutomático (conforme nodes)
Node updatesNão gerenciadoAuto-gerenciado

Boas Práticas​

1. Usar para Serviços de Sistema​

DaemonSets para agentes de sistema, não para aplicações de negócio.

2. Recursos Apropriados​

Defina limites de recursos para evitar esgotamento.

3. Tolerations​

Adicione tolerations para nodes tainted se necessário.

4. Monitoramento​

Monitore se todos os nodes possuem um Pod do DaemonSet.

5. Namespace​

Coloque DaemonSets de sistema em kube-system ou em um namespace dedicado.

Resumo​

Neste capítulo, você aprendeu:

DaemonSet: Um Pod por node do cluster
Casos de uso: Agentes de logging, monitoramento, segurança, rede
Node selectors: Deploy em nodes específicos
Tolerations: Rodar em nodes tainted
Atualizações: RollingUpdate ou OnDelete
Diferenças: Um por node vs número específico
Boas práticas: Serviços de sistema, recursos, monitoramento

Próximos Passos​

Capítulo 7.3: Jobs
Capítulo 7.4: CronJobs

Capítulo criado em: Dezembro 2024