Kubernetes Basics · Aula

DaemonSets para tarefas específicas de nós

Use DaemonSets para executar uma cópia de um pod em todos os nós ou em nós selecionados do seu cluster para operações no nível do cluster.

DaemonSets para tarefas específicas de nós é uma aula grátis de Kubernetes Basics no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kubernetes Basics, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kubernetes Basics inclui 4 aulas no total.

O que são DaemonSets?

Imagine que você precise executar uma ferramenta ou um serviço específico em cada servidor do seu cluster. Por exemplo, um agente de registro que coleta registros de cada máquina.

É nesse cenário que entram os DaemonSets! Diferentemente das implantações, que buscam manter determinada quantidade de Pods em execução em algum lugar do cluster, um DaemonSet garante que uma cópia de um Pod seja executada em todos os nós (ou nos nós selecionados).

Usos comuns dos DaemonSets

Os DaemonSets são perfeitos para tarefas que precisam ser executadas no nível do nó. Veja alguns exemplos comuns:

Agentes de registro: ferramentas como Fluentd ou Logstash para coletar registros de cada nó.
Agentes de monitoramento: o Prometheus Node Exporter para coletar métricas de cada servidor.
Daemons de armazenamento: serviços como GlusterFS ou Ceph, que fornecem armazenamento distribuído em cada nó.
Proxies de rede: o Kube-proxy do próprio Kubernetes é executado como um DaemonSet para gerenciar regras de rede.

Manifesto básico de DaemonSet

A definição de um DaemonSet é muito semelhante à de uma implantação. A principal diferença é kind: DaemonSet. Veja uma estrutura básica:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: my-daemonset
spec:
  selector:
    matchLabels:
      app: my-daemonset-app
  template:
    metadata:
      labels:
        app: my-daemonset-app
    spec:
      containers:
      - name: my-container
        image: busybox
        command: ["sh", "-c", "echo 'Hello from DaemonSet on node $(NODE_NAME)'; sleep 3600"]
        env:
        - name: NODE_NAME
          valueFrom:
            fieldRef:
              fieldPath: spec.nodeName

Partes principais do YAML

Vamos analisar as seções importantes do nosso manifesto de DaemonSet:

kind: DaemonSet: informa ao Kubernetes que queremos gerenciar Pods específicos de cada nó.
spec.selector: essencial! Define como o DaemonSet encontra e gerencia seus Pods usando rótulos.
spec.template: é a própria definição do Pod. Ela é quase idêntica ao modelo de Pod encontrado em uma implantação. Descreve os contêineres, os volumes e outras configurações do Pod que será executado em cada nó.

Implantação em todos os nós

Aqui está um DaemonSet simples que executa um contêiner busybox em cada nó elegível. Ele exibirá uma mensagem indicando em qual nó está sendo executado.

Esse é um padrão comum para agentes que abrangem todo o cluster.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-hello-daemon
spec:
  selector:
    matchLabels:
      app: node-hello
  template:
    metadata:
      labels:
        app: node-hello
    spec:
      containers:
      - name: hello-container
        image: busybox
        command: ["sh", "-c", "while true; do echo 'Hello from node: $(NODE_NAME)'; sleep 5; done"]
        env:
        - name: NODE_NAME
          valueFrom:
            fieldRef:
              fieldPath: spec.nodeName

Iniciando seu DaemonSet

Para criar o DaemonSet no seu cluster do Kubernetes, use o conhecido comando kubectl apply com o arquivo YAML que você acabou de ver:

kubectl apply -f node-hello-daemonset.yaml

Em seguida, o Kubernetes garantirá que um Pod seja agendado em cada nó que corresponda aos critérios do DaemonSet.

Verificando a integridade do DaemonSet

Depois de aplicar a configuração, você poderá verificar o status do DaemonSet e dos Pods que ele criou:

Para ver o DaemonSet: kubectl get ds
Para ver os Pods individuais em execução em cada nó: kubectl get pods -l app=node-hello -o wide

A opção -o wide ajuda a ver em qual nó cada Pod está agendado.

DaemonSets em nós selecionados

E se você quiser que o DaemonSet seja executado apenas em um subconjunto dos seus nós? Por exemplo, somente em nós com uma GPU ou em nós dedicados ao armazenamento.

Você pode fazer isso usando nodeSelector. Esse campo no spec do Pod (dentro do modelo do DaemonSet) permite especificar os rótulos que um nó precisa ter para que o Pod seja agendado nele.

Usando seletores de nós em YAML

Vamos modificar o DaemonSet anterior para que ele seja executado somente em nós rotulados com disktype: ssd. Primeiro, você precisaria rotular seus nós, por exemplo, com kubectl label node <node-name> disktype=ssd.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: ssd-monitor-daemon
spec:
  selector:
    matchLabels:
      app: ssd-monitor
  template:
    metadata:
      labels:
        app: ssd-monitor
    spec:
      nodeSelector:
        disktype: ssd # Only runs on nodes with this label
      containers:
      - name: monitor-container
        image: busybox
        command: ["sh", "-c", "while true; do echo 'Monitoring SSD on node: $(NODE_NAME)'; sleep 10; done"]
        env:
        - name: NODE_NAME
          valueFrom:
            fieldRef:
              fieldPath: spec.nodeName

Recursos dos DaemonSets

Você aprendeu como os DaemonSets funcionam. Vamos testar sua compreensão!

DaemonSets: principais conclusões

Excelente trabalho! Você aprendeu com sucesso sobre os DaemonSets do Kubernetes.

Os DaemonSets garantem que um Pod seja executado em cada nó elegível.
Eles são essenciais para operações no nível do nó, como agentes de registro, monitoramento e armazenamento.
Você pode usar nodeSelector para direcionar nós específicos.
Os DaemonSets são definidos com kind: DaemonSet e usam um modelo de Pod, de forma semelhante às implantações.

Em seguida, você explorará os StatefulSets para gerenciar aplicações com estado!

Perguntas Frequentes

A aula “DaemonSets para tarefas específicas de nós” é grátis?

Sim — o texto completo de “DaemonSets para tarefas específicas de nós” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kubernetes Basics, atualize para CoddyKit PRO. O curso de Kubernetes Basics inclui 4 aulas no total.

O que vou aprender em “DaemonSets para tarefas específicas de nós”?

Use DaemonSets para executar uma cópia de um pod em todos os nós ou em nós selecionados do seu cluster para operações no nível do cluster. Você pratica Kubernetes Basics com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kubernetes Basics?

Nenhuma experiência prévia é necessária. Kubernetes Basics no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “DaemonSets para tarefas específicas de nós”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kubernetes Basics?

Sim. Cada aula de Kubernetes Basics inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

StatefulSets para aplicações com estado
DaemonSets para tarefas específicas de nós
Entendendo os Operators do Kubernetes
Definições de Recursos Personalizados (CRDs)

← Voltar para Kubernetes Basics