Kubernetes: Comandos Cordon e Uncordon para Gerenciamento de Nós

Introdução

Num cluster Kubernetes, os nós podem assumir vários estados, como "ready" (pronto) ou "not ready" (não pronto). Os comandos cordon e uncordon são usados para controlar o agendamento de pods em um nó específico. O comando cordon marca um nó como "unschedulable" (não agendável), impedindo que novos pods sejam agendados nesse nó, enquanto o comando uncordon marca o nó como "schedulable" (agendável) novamente, permitindo que novos pods sejam agendados nesse nó. Neste laboratório, exploraremos como usar esses comandos para controlar o agendamento de pods em nós em um cluster Kubernetes.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 100%. Recebeu uma taxa de avaliações positivas de 97% dos estudantes.

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
```
Iniciar 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.
Verificar 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.

Cordonando um Nó

Nesta etapa, usaremos o comando cordon para marcar um nó como "unschedulable" (não agendável), impedindo que novos pods sejam agendados nesse nó. Aqui estão os passos:

Liste os nós no cluster usando o seguinte comando:
```
kubectl get nodes
```
Cordon o nó usando o seguinte comando:
```
kubectl cordon minikube
```
Verifique se o nó foi cordoned verificando o campo SchedulingDisabled no status do nó usando o seguinte comando:
```
kubectl get node | grep SchedulingDisabled
```

Descordonando um Nó

Nesta etapa, usaremos o comando uncordon para marcar um nó como "schedulable" (agendável) novamente, permitindo que novos pods sejam agendados nesse nó. Aqui estão os passos:

Descordone o nó usando o seguinte comando:
```
kubectl uncordon minikube
```
Verifique se o nó foi descordonado verificando o campo SchedulingDisabled no status do nó usando o seguinte comando:
```
kubectl get node | grep SchedulingDisabled
```

Cordonando e Descordonando Nós com Pods

Nesta etapa, simularemos um cenário em que um nó precisa ser cordoned e descordonado enquanto possui pods em execução nele. Aqui estão os passos:

Execute o seguinte comando para entrar no diretório /home/labex/project/:
```
cd /home/labex/project/
```

Crie um deployment (implantação) chamado "deploy.yaml" com múltiplas cópias usando o seguinte arquivo YAML no diretório /home/labex/project/:

## deploy.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 1
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.16
          ports:
            - containerPort: 80

Cordon o nó usando o seguinte comando:
```
kubectl cordon minikube
```
Aplique o arquivo YAML usando o seguinte comando:
```
kubectl apply -f deploy.yaml
```
Liste os pods em execução nos nós usando o seguinte comando:
```
kubectl get pods -o wide
```
Verifique se o Pod foi agendado e iniciado corretamente.
Descordone o nó usando o seguinte comando:
```
kubectl uncordon minikube
```
Verifique o status dos pods em execução no nó para garantir que eles sejam reagendados no nó descordonado usando o seguinte comando:
```
kubectl get pods -o wide
```

Usando Labels para Cordonar e Descordonar Nós

Nesta etapa, usaremos labels (rótulos) para cordonar e descordonar nós com base em critérios específicos. Aqui estão os passos:

Rotule os nós no cluster usando o seguinte comando:
```
kubectl label nodes minikube org=labex
```
Cordon os nós que possuem o label especificado usando o seguinte comando:
```
kubectl cordon -l org=labex
```
Verifique se os nós foram cordonados verificando o campo SchedulingDisabled no status dos nós usando o seguinte comando:
```
kubectl get node -l org=labex | grep SchedulingDisabled
```
Descordone os nós que possuem o label especificado usando o seguinte comando:
```
kubectl uncordon -l org=labex
```
Verifique se os nós foram descordonados verificando o campo SchedulingDisabled no status dos nós usando o seguinte comando:
```
kubectl get node -l org=labex | grep SchedulingDisabled
```

Resumo

Neste laboratório, exploramos como usar os comandos cordon e uncordon no Kubernetes para controlar o agendamento de pods em nós. Aprendemos como cordonar e descordonar nós, mesmo com pods em execução, e como usar labels (rótulos) para cordonar e descordonar nós seletivamente com base em critérios específicos. Esses comandos são úteis para gerenciar a disponibilidade e a resiliência de pods em um cluster Kubernetes.

Comando Cordon e Uncordon do Kubernetes