Agendamento com Seletores de Nó Kubernetes

Introdução

Neste laboratório, começaremos criando um deployment simples e, em seguida, atribuiremos Seletores de Nó (Node Selectors) a ele. Em seguida, passaremos para cenários mais complexos, onde usaremos diferentes seletores para agendar pods em nós específicos.

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 95%. Recebeu uma taxa de avaliações positivas de 96% 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.
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 Deployment Simples

Nesta etapa, criaremos um deployment simples com um único pod.

Crie um arquivo chamado simple-deployment.yaml com o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: simple-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: simple-app
  template:
    metadata:
      labels:
        app: simple-app
    spec:
      containers:
        - name: simple-container
          image: nginx:latest

Use kubectl para criar o deployment:

kubectl apply -f simple-deployment.yaml

Verifique se o deployment foi criado:

kubectl get deployments

Atribuindo Seletores de Nó a um Deployment

Nesta etapa, atribuiremos um Seletor de Nó (Node Selector) ao deployment que criamos na Etapa 1.

Crie os nós com um rótulo (label):

kubectl label nodes minikube disk=ssd

Edite o arquivo node-selector-deployment.yaml e adicione o campo nodeSelector na seção spec.template.spec:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: selector-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: selector-app
  template:
    metadata:
      labels:
        app: selector-app
    spec:
      nodeSelector:
        disk: ssd
      containers:
        - name: selector-container
          image: nginx:latest

Use kubectl para aplicar as alterações:

kubectl apply -f node-selector-deployment.yaml

Verifique se o pod foi agendado em um nó com o rótulo disk=ssd:

kubectl get pods -o wide | grep selector-deployment

Usando Seletores de Nó Diferentes

Nesta etapa, usaremos diferentes Seletores de Nó (Node Selectors) para agendar pods em nós específicos com base nos rótulos atribuídos a esses nós.

Crie três nós com rótulos diferentes:

kubectl label nodes minikube resigon=labex
kubectl label nodes minikube gpu=true

Crie um arquivo chamado multi-selector-deployment.yaml com o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: multi-selector-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: multi-selector-app
  template:
    metadata:
      labels:
        app: multi-selector-app
    spec:
      containers:
        - name: multi-selector-container
          image: nginx:latest
      nodeSelector:
        resigon: labex
        gpu: "true"

Aplique as alterações:

kubectl apply -f multi-selector-deployment.yaml

Verifique se os pods foram agendados em nós com os rótulos apropriados:

kubectl get pods -o wide | grep multi-selector-deployment

Resumo

Neste laboratório, aprendemos como agendar pods em nós específicos usando Seletores de Nó (Node Selectors) e Afinidade de Nó (Node Affinity). Começamos com um deployment simples e, em seguida, passamos para cenários mais complexos, onde usamos diferentes seletores e regras de afinidade para agendar pods em nós específicos com base nos rótulos atribuídos a esses nós.

Parabéns! Você concluiu este laboratório com sucesso.