Agendamento com Afinidade de Nó (Node Affinity)

Introdução

No Kubernetes, a afinidade de nó (node affinity) é utilizada para agendar pods em nós que atendem a determinadas condições. Isso pode ser usado para garantir que os pods sejam agendados em tipos específicos de nós ou para equilibrar a carga de trabalho entre eles. Neste laboratório, aprenderemos como usar a afinidade de nó 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. O Minikube é um ambiente Kubernetes leve que roda em sua máquina local.

Navegue até o seu diretório de trabalho:

Abra o terminal e navegue até a pasta padrão do projeto:
```
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.
- Se o cluster não estiver em execução, execute minikube start novamente.

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

Execute as etapas restantes deste laboratório a partir de /home/labex/project para que os arquivos YAML permaneçam no mesmo diretório de trabalho.

Criar um Nó com Rótulos

Nesta etapa, criaremos um nó com um rótulo que será usado para agendar pods.

Crie um arquivo chamado node-with-label.yaml com o seguinte conteúdo no diretório /home/labex/project:

apiVersion: v1
kind: Node
metadata:
  name: minikube
  labels:
    type: web

Aplique as alterações:

kubectl apply -f node-with-label.yaml

Verifique se o nó foi criado e rotulado:

kubectl get nodes --show-labels

Criar um Pod com Afinidade de Nó

Nesta etapa, criaremos um pod com uma regra de afinidade de nó que garantirá que ele seja agendado em um nó com um rótulo específico.

Crie um arquivo chamado pod-with-node-affinity.yaml com o seguinte conteúdo no diretório /home/labex/project:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-node-affinity
spec:
  containers:
    - name: nginx
      image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: In
                values:
                  - web

Aplique as alterações:

kubectl apply -f pod-with-node-affinity.yaml

Verifique se o pod foi agendado no nó com o rótulo type=web:

kubectl get pod pod-with-node-affinity -o wide

Criar um Pod com Anti-Afinidade de Nó

Nesta etapa, criaremos um pod com uma regra de anti-afinidade de nó que garantirá que ele não seja agendado em um nó com um rótulo específico.

Crie um arquivo chamado pod-with-node-anti-affinity.yaml com o seguinte conteúdo no diretório /home/labex/project:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-node-anti-affinity
spec:
  containers:
    - name: nginx
      image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: NotIn
                values:
                  - web

Aplique as alterações:

kubectl apply -f pod-with-node-anti-affinity.yaml

Verifique se o pod não foi agendado no nó com o rótulo type=db:

kubectl get pod pod-with-node-anti-affinity -o wide

Criar um Pod com Afinidade de Nó e Seletor de Nó

Nesta etapa, criaremos um pod com uma regra de afinidade de nó e um seletor de nó (node selector) que garantirão que ele seja agendado em um nó com um rótulo específico.

Crie um arquivo chamado pod-with-node-affinity-and-selector.yaml com o seguinte conteúdo no diretório /home/labex/project:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-node-affinity-and-selector
spec:
  containers:
    - name: nginx
      image: nginx:latest
  nodeSelector:
    type: web
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: In
                values:
                  - db

Aplique as alterações:

kubectl apply -f pod-with-node-affinity-and-selector.yaml

Verifique se o pod não foi agendado no nó com o rótulo type=web:

kubectl get pod pod-with-node-affinity-and-selector -o wide

Criar um Pod com Múltiplas Regras de Afinidade de Nó

Nesta etapa, criaremos um pod com múltiplas regras de afinidade de nó que garantirão que ele seja agendado em um nó com rótulos que correspondam a todas as regras.

Crie um arquivo chamado pod-with-multiple-node-affinity.yaml com o seguinte conteúdo no diretório /home/labex/project:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-multiple-node-affinity
spec:
  containers:
    - name: nginx
      image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: In
                values:
                  - web
          - matchExpressions:
              - key: disktype
                operator: In
                values:
                  - ssd

Aplique as alterações:

kubectl apply -f pod-with-multiple-node-affinity.yaml

Verifique se o pod foi agendado no nó com os rótulos type=web e disktype=ssd:

kubectl get pod pod-with-multiple-node-affinity -o wide

Resumo

Neste laboratório, aprendemos como usar a afinidade de nó para agendar pods em nós específicos. Criamos um nó com um rótulo e, em seguida, criamos pods com regras de afinidade de nó que garantiram que eles fossem agendados em nós com rótulos específicos. Também criamos um pod com uma regra de anti-afinidade de nó que garantiu que ele não fosse agendado em um nó com um rótulo específico. Por fim, criamos um pod com múltiplas regras de afinidade de nó que garantiram que ele fosse agendado em um nó com rótulos que correspondiam a todas as regras.