Pular para o conteúdo principal

Lab 7.2 - DaemonSet para Monitoramento

Objetivos do Lab​

Ao final deste lab, você será capaz de:

  • Compreender o conceito de DaemonSet.
  • Criar um DaemonSet para implantar um agente de monitoramento.
  • Verificar que o DaemonSet está rodando em todos os nós.
  • Entender os casos de uso dos DaemonSets.
  • Gerenciar DaemonSets (atualização, remoção).

Duração Estimada​

45-60 minutos

Pré-requisitos​

  • kubectl instalado e configurado.
  • Cluster Kubernetes local funcional (minikube ou kind).
  • Conhecimento sobre DaemonSets (Capítulo 7.2).

Parte 1: Compreendendo os DaemonSets​

Um DaemonSet garante que uma cópia de um Pod seja executada em cada nó (ou em um subconjunto de nós). Isso é ideal para:

  • Agentes de monitoramento (ex: node-exporter)
  • Agentes de logging (ex: Fluentd, Fluent Bit)
  • Agentes de segurança
  • Coletores de métricas

Etapa 1.1: Verificar os Nós​

Verifique os nós do seu cluster:

kubectl get nodes

Para um cluster local (minikube/kind), geralmente haverá apenas um nó.

Parte 2: Criação de um DaemonSet Simples​

Vamos criar um DaemonSet que simula um agente de monitoramento simples.

Etapa 2.1: Criar o DaemonSet​

Crie um arquivo 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

Explicação:

  • O DaemonSet cria um Pod em cada nó.
  • O container monta /proc e /sys do nó para acessar métricas do sistema.
  • O container exibe periodicamente informações do nó.

Aplique o DaemonSet:

kubectl apply -f daemonset-monitoring.yaml

Parte 3: Verificação do DaemonSet​

Etapa 3.1: Verificar os Pods Criados​

Verifique se os Pods foram criados:

kubectl get pods -l app=node-monitor

Você deve ver um Pod por nó. Para um cluster com apenas um nó, verá um Pod.

Verifique em quais nós os Pods estão rodando:

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

Etapa 3.2: Verificar o Status do DaemonSet​

Verifique o status do DaemonSet:

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

Você deve ver:

  • DESIRED: Número de nós onde o Pod deveria rodar
  • CURRENT: Número de Pods atualmente criados
  • READY: Número de Pods prontos
  • UP-TO-DATE: Número de Pods atualizados com o template
  • AVAILABLE: Número de Pods disponíveis

Etapa 3.3: Verificar os Logs​

Verifique os logs de um Pod para ver as métricas coletadas:

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

Você deve ver mensagens periódicas com as informações do nó.

Parte 4: Teste de Adição de Nó (Simulação)​

Se você tivesse vários nós, o DaemonSet criaria automaticamente um Pod em cada novo nó. Para um cluster local, vamos simular isso verificando o comportamento.

Etapa 4.1: Verificar o Comportamento​

O DaemonSet monitora automaticamente os nós. Se um novo nó for adicionado ao cluster, um Pod será criado automaticamente nesse nó.

Verifique a descrição do DaemonSet para ver os detalhes:

kubectl describe daemonset node-monitor

Parte 5: Atualização do DaemonSet​

Etapa 5.1: Atualizar a Imagem​

Altere o DaemonSet para mudar a frequência de coleta:

# 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) - Monitoramento ativo"
            sleep 10 # Alterado de 30 para 10 segundos
          done
        resources:
          requests:
            cpu: 100m
            memory: 64Mi
          limits:
            cpu: 200m
            memory: 128Mi

Aplique a atualização:

kubectl apply -f daemonset-monitoring-updated.yaml

Etapa 5.2: Observar a Atualização​

Os Pods do DaemonSet são atualizados de forma rolling (um por vez):

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

Você verá os Pods antigos sendo removidos e os novos sendo criados.

Verifique os novos logs:

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

Você deve ver as mensagens com "[UPDATED]" e uma frequência maior.

Parte 6: Node Selectors e Taints​

Etapa 6.1: Usar um Node Selector (Opcional)​

Você pode limitar os nós onde o DaemonSet roda usando um nodeSelector:

spec:
  template:
    spec:
      nodeSelector:
        kubernetes.io/os: linux # Executa apenas em nós Linux
      containers:
      # ...

Etapa 6.2: Tolerar Taints (Opcional)​

Se alguns nós tiverem taints, você pode adicionar tolerations ao DaemonSet:

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

Parte 7: Limpeza​

Remova o DaemonSet:

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

Todos os Pods criados pelo DaemonSet serão removidos automaticamente.

Resumo do Lab​

Neste lab, você explorou os DaemonSets para monitoramento. Você aprendeu a criar um DaemonSet que roda em todos os nós, verificar seu comportamento, atualizá-lo e entender os casos de uso típicos (monitoramento, logging, segurança).

Próximos Passos​

O próximo lab mostrará como usar Jobs e CronJobs para executar tarefas pontuais e agendadas.

Lab 7.3: Jobs e CronJobs

Lab criado em: Dezembro 2024