# Como gerenciar clusters com Kubernetes DaemonSet

O Kubernetes DaemonSet simplifica o gerenciamento das aplicações ou serviços necessários para executar cada nó no cluster. As configurações e alterações em um DaemonSet são aplicadas automaticamente a todos os nós.

## O que é Kubernetes DaemonSet?

Kubernetes DaemonSet é um recurso que assegura que pelo menos uma instância de um pod específico seja executada em cada nó no cluster. Assim, a aplicação ou serviço tem uma **presença global em todo o ambiente do cluster**. DaemonSets são especialmente adequados para a execução de tarefas como monitoramento, registro ou serviços de rede que precisam ficar disponíveis em todos os nós no cluster. Uma grande vantagem do Kubernetes DaemonSet é sua escalabilidade, pois ele inicia automaticamente novos pods e exclui os existentes quando os nós falham ou são removidos. Como resultado, o DaemonSet aumenta o nível de confiabilidade e facilita o gerenciamento de clusters.

Dica Com a solução [Managed Kubernetes](https://cloud.ionos.com/managed/kubernetes "Managed Kubernetes — IONOS") da IONOS, você desfruta de uma configuração de clusters totalmente automatizada, alto desempenho nas cargas de trabalho e proteção contra falhas.

## Como configurar o Kubernetes DaemonSet

A distribuição de pods é controlada de maneira granular tomando como base as **propriedades dos nós, requisitos de recursos** ou outros critérios definidos pelo usuário. A seguir, explicaremos como configurar e usar um Kubernetes DaemonSet.

### Criar arquivo YAML DaemonSet

Primeiro, você defina a configuração do DaemonSet em um arquivo **YAML**. Esse tipo de arquivo contém informações como o nome do DaemonSet, o tipo de pod usado e as configurações específicas de posicionamento para os nós.

Este é um exemplo de arquivo YAML que cria um pod com um contêiner NGINX em cada nó:

```yaml
apiVersion: apps/v1 
kind: DaemonSet 
metadata: 
    name: nginx-daemonset 
spec: 
    selector: 
        matchLabels: 
            app: nginx 
    template: 
        metadata: 
            labels: 
                app: nginx 
        spec: 
            containers: 
            - name: nginx-container 
                image: nginx:latest
```

### Ativar configuração pelo YAML

Abra a linha de comando e acesse o diretório em que o seu arquivo YAML DaemonSet foi salvo. Em seguida, execute o comando `kubectl apply` para aplicar a configuração no seu **cluster do Kubernetes**:

```shell
kubectl apply -f daemonset.yaml
```

Esse comando informa ao cluster do Kubernetes para criar ou atualizar os recursos definidos no arquivo YAML.

### Verificar Kubernetes DaemonSet

Verifique se os pods desejados foram iniciados com sucesso em cada nó.

```shell
kubectl get daemonset
```

O resultado desse comando contém informações relevantes, incluindo:

- **DESIRED**: O número desejado de pods a serem criados pelo DaemonSet.
- **CURRENT**: O número real de pods fornecido.
- **READY**: O número de pods disponíveis e prontos para operação.
- **UP-TO-DATE**: O número de pods atualizados de acordo com a configuração do DaemonSet.
- **AVAILABLE**: O número de pods operacionais não afetados por outros recursos, como afinidades ou tolerâncias.
- **NODE SELECTOR**: Marcações (*labels*) para os nós em que o DaemonSet será executado (se configurado).
- **AGE**: O tempo decorrido desde que o DaemonSet foi criado.

No nosso exemplo, observe que o Kubernetes DaemonSet chamado `nginx-daemonset` tem três pods desejados e três pods em execução nos nós.

```shell
NAME                      DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE 
nginx-daemonset              3          3                 3                  3                       3                    <none>           5m
```

### Verificar pods

Para obter uma visão mais detalhada dos pods criados, use o seguinte comando:

```shell
kubectl get pods
```

O resultado exibirá a situação atual dos pods, incluindo se eles estão prontos para operação, qual é seu status e há quanto tempo eles são executados.

```shell
NAME                                   READY   STATUS    RESTARTS       AGE 
nginx-daemonset-abcde     1/1      Running            0               5m 
nginx-daemonset-fghij     1/1      Running               0               5m 
nginx-daemonset-klmno     1/1      Running            0               5m
```

### Excluir Kubernetes DaemonSet

Primeiro, verifique quais DaemonSets estão presentes no seu cluster. Depois, insira o comando `kubectl delete daemonset` seguido pelo nome do DaemonSet que será excluído no console. Por exemplo:

```shell
kubectl delete daemonset nginx-daemonset
```

### Limitar Kubernetes DaemonSet a nós específicos

Para executar um DaemonSet em nós específicos de um cluster do Kubernetes, você pode usar seletores de nós ou afinidades nas configurações do DaemonSet. Essas definições possibilitam especificar em quais nós os pods do DaemonSet serão criados.

```yaml
apiVersion: apps/v1 
kind: DaemonSet 
metadata: 
    name: nginx-daemonset 
spec: 
    selector: 
        matchLabels: 
            app: nginx 
    template: 
        metadata: 
            labels: 
                app: nginx 
        spec: 
            nodeSelector: 
                custom-label: special-node 
            containers: 
            - name: nginx-container 
                image: nginx:latest
```

Nesse exemplo, o DaemonSet foi configurado para ser executado somente em nós com a *label* `custom-label: special-node`.

### Comunicar-se com pods do DaemonSet

Existem diferentes formas de se comunicar com os pods de um Kubernetes DaemonSet, dependendo dos requisitos da sua aplicação.

- **Push**: Os pods do DaemonSet enviam dados ou atualizações para um serviço externo, como um banco de dados de estatísticas ou sistema central de logs. Os pods do DaemonSet não têm clientes e não iniciam conexões de entrada.
- **IP do nó e porta conhecida**: Com esse método, cada pod do DaemonSet usa uma porta específica no nó para se tornar acessível. Os clientes conhecem a lista de IPs dos nós disponíveis e acessam os pods por meio do IP e da porta do respectivo nó.
- **DNS**: Ao usar a ferramenta `__headless service__` com o mesmo seletor de pods que o Kubernetes DaemonSet, você habilita a resolução de DNS individual para os pods. Os clientes conseguem se comunicar com os pods do DaemonSet usando o recurso “Endpoints” ou consultando múltiplos registros DNS do tipo A.
- **Serviço**: A criação de um serviço no Kubernetes com o mesmo seletor de pods oferece aos clientes acesso aos pods do DaemonSet. O procedimento ocorre por meio do endereço IP do cluster do serviço. Observe que esse processo não garante que um nó específico será alcançado. Em vez disso, o serviço encaminhará a solicitação para um dos pods disponíveis do DaemonSet.

Você encontra informações detalhadas sobre o gerenciamento de clusters no [tutorial de Kubernetes](https://www.ionos.com/digitalguide/server/configuration/kubernetes-tutorial/ "Tutorial Kubernetes") no nosso Digital Guide.


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/kubernetes-daemonset/](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/kubernetes-daemonset/) for AI/LLM consumption.