Taints e Tolerâncias Kubernetes: Agendamento e Afinidade de Nós

Introdução

Taints e tolerâncias são usados no Kubernetes para especificar quais nós são adequados para agendar certos pods. Taints são aplicados aos nós para repelir pods, enquanto tolerâncias são aplicadas aos pods para atraí-los para nós específicos. Neste laboratório, aprenderemos como usar taints e tolerâncias para agendar pods em nós específicos.

Iniciar o Cluster Minikube

Antes de criar recursos, você precisa de um cluster Kubernetes em execução. Minikube é um ambiente Kubernetes leve que roda em sua máquina local.

Navegue para o seu diretório de trabalho:

Abra o terminal e navegue até a pasta do projeto padrão:
```
cd /home/labex/project
```
Inicie o Minikube:

Inicie o Minikube para inicializar um cluster Kubernetes:
```
minikube start
```
- Este comando configura um cluster Kubernetes de nó único em sua máquina local.
- O Minikube pode levar alguns minutos para iniciar, dependendo do desempenho do seu sistema.
Verifique se o Minikube está em execução:

Verifique o status do cluster Minikube:
```
minikube status
```
- Procure por componentes como kubelet e apiserver listados como Running (Em execução).
- Se o cluster não estiver em execução, execute novamente minikube start.

Se você encontrar problemas ao iniciar o Minikube. Use minikube delete para redefinir o ambiente, se necessário.

Criando um Nó com Taint

Nesta etapa, criaremos um nó com um taint que repelirá certos pods.

Rotule um nó com um rótulo (label) personalizado:
```
kubectl label nodes minikube disk-type=ssd
```
Aplique o taint ao nó com o seguinte comando:
```
kubectl taint nodes minikube disk-type=ssd:NoSchedule
```
O efeito NoSchedule impedirá que pods sem tolerâncias sejam agendados neste nó.

Criando um Pod sem Tolerâncias

Nesta etapa, criaremos um pod sem tolerâncias e verificaremos que ele não pode ser agendado no nó tainted.

Crie um arquivo chamado pod-without-toleration.yaml com o seguinte conteúdo:

apiVersion: v1
kind: Pod
metadata:
  name: pod-without-toleration
spec:
  containers:
    - name: nginx
      image: nginx:latest

Aplique as alterações:

kubectl apply -f pod-without-toleration.yaml

Verifique se o pod não está agendado no nó tainted:
```
kubectl describe pod pod-without-toleration | grep -i taint
```
A saída deve mostrar que o pod não está agendado no nó com o taint.

Criando um Pod com Tolerâncias

Nesta etapa, criaremos um pod com tolerâncias que permitirão que ele seja agendado no nó tainted.

Crie um arquivo chamado pod-with-toleration.yaml com o seguinte conteúdo:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-toleration
spec:
  containers:
    - name: nginx
      image: nginx:latest
  tolerations:
    - key: "disk-type"
      operator: "Equal"
      value: "ssd"
      effect: "NoSchedule"

Aplique as alterações:

kubectl apply -f pod-with-toleration.yaml

Verifique se o pod está agendado no nó tainted:
```
kubectl get pod pod-with-toleration -o wide
```

Tolerando Múltiplos Taints

Nesta etapa, criaremos um pod com múltiplas tolerâncias que permitirão que ele seja agendado em nós com múltiplos taints.

Crie um arquivo chamado pod-with-multiple-tolerations.yaml com o seguinte conteúdo:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-multiple-tolerations
spec:
  containers:
    - name: nginx
      image: nginx:latest
  tolerations:
    - key: "disk-type"
      operator: "Equal"
      value: "ssd"
      effect: "NoSchedule"
    - key: "gpu"
      operator: "Equal"
      value: "true"
      effect: "NoSchedule"

Aplique as alterações:

kubectl apply -f pod-with-multiple-tolerations.yaml

Verifique se o pod está agendado em um nó com ambos os taints:
```
kubectl get pod pod-with-multiple-tolerations -o wide
```

Resumo

Neste laboratório, aprendemos como usar taints e tolerâncias para agendar pods em nós específicos. Começamos criando um nó tainted e verificando que pods sem tolerâncias não podiam ser agendados nele. Em seguida, criamos um pod com tolerâncias e verificamos que ele podia ser agendado no nó tainted. Finalmente, criamos um pod com múltiplas tolerâncias e verificamos que ele podia ser agendado em nós com múltiplos taints.

Taints e tolerâncias são um recurso poderoso do Kubernetes que pode ser usado para garantir que certas cargas de trabalho sejam agendadas apenas em nós específicos.