Taints y tolerancias

Introducción

Las taints (manchas) y tolerancias se utilizan en Kubernetes para especificar qué nodos son adecuados para programar ciertos pods. Las taints se aplican a los nodos para repeler los pods, mientras que las tolerancias se aplican a los pods para atraerlos a nodos específicos. En este laboratorio, aprenderemos cómo usar taints y tolerancias para programar pods en nodos específicos.

Skills Graph

Iniciar el clúster de Minikube

Antes de crear recursos, necesitas un clúster de Kubernetes en ejecución. Minikube es un entorno ligero de Kubernetes que se ejecuta en tu máquina local.

1. Navegar a tu directorio de trabajo:

   Abre la terminal y navega hasta la carpeta de proyecto predeterminada:

   cd /home/labex/project

2. Iniciar Minikube:

   Inicia Minikube para inicializar un clúster de Kubernetes:

   minikube start

   • Este comando configura un clúster de Kubernetes de un solo nodo en tu máquina local.
   • Minikube puede tardar unos minutos en iniciar, dependiendo del rendimiento de tu sistema.

3. Verificar que Minikube esté en ejecución:

   Comprueba el estado del clúster de Minikube:

   minikube status

   • Busca componentes como kubelet y apiserver listados como Running (En ejecución).
   • Si el clúster no está en ejecución, vuelve a ejecutar minikube start.

Si encuentras problemas al iniciar Minikube, utiliza minikube delete para restablecer el entorno si es necesario.

Crear un nodo con taint (mancha)

En este paso, crearemos un nodo con una taint (mancha) que repelerá ciertos pods.

1. Etiquetar un nodo con una etiqueta personalizada:

kubectl label nodes minikube disk-type=ssd

2. Aplicar una taint al nodo con el siguiente comando:

kubectl taint nodes minikube disk-type=ssd:NoSchedule

El efecto NoSchedule evitará que los pods sin tolerancias se programen en este nodo.

Crear un pod sin tolerancias

En este paso, crearemos un pod sin tolerancias y verificaremos que no se puede programar en el nodo con taint (mancha).

1. Crea un archivo llamado pod-without-toleration.yaml con el siguiente contenido:

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

2. Aplica los cambios:

kubectl apply -f pod-without-toleration.yaml

3. Verifica que el pod no se haya programado en el nodo con taint:

kubectl describe pod pod-without-toleration | grep -i taint

La salida debe mostrar que el pod no se ha programado en el nodo con la taint.

Crear un pod con tolerancias

En este paso, crearemos un pod con tolerancias que le permitirán ser programado en el nodo con taint (mancha).

1. Crea un archivo llamado pod-with-toleration.yaml con el siguiente contenido:

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"

2. Aplica los cambios:

kubectl apply -f pod-with-toleration.yaml

3. Verifica que el pod se haya programado en el nodo con taint:

kubectl get pod pod-with-toleration -o wide

Tolerar múltiples taints (manchas)

En este paso, crearemos un pod con múltiples tolerancias que le permitirán ser programado en nodos con múltiples taints (manchas).

1. Crea un archivo llamado pod-with-multiple-tolerations.yaml con el siguiente contenido:

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"

2. Aplica los cambios:

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

3. Verifica que el pod se haya programado en un nodo con ambas taints (manchas):

kubectl get pod pod-with-multiple-tolerations -o wide

Resumen

En este laboratorio, aprendimos cómo usar taints (manchas) y tolerancias para programar pods en nodos específicos. Comenzamos creando un nodo con taint (mancha) y verificando que los pods sin tolerancias no se podían programar en él. Luego, creamos un pod con tolerancias y verificamos que se podía programar en el nodo con taint (mancha). Finalmente, creamos un pod con múltiples tolerancias y verificamos que se podía programar en nodos con múltiples taints (manchas).

Las taints (manchas) y las tolerancias son una característica poderosa de Kubernetes que se pueden utilizar para garantizar que ciertas cargas de trabajo solo se programen en nodos específicos.