Programación con Afinidad de Nodo (Node Affinity)

Introducción

En Kubernetes, la afinidad de nodo (node affinity) se utiliza para programar pods en nodos que cumplan ciertas condiciones. Esto se puede utilizar para garantizar que los pods se programen en tipos específicos de nodos o para equilibrar la carga de trabajo entre los nodos. En este laboratorio (lab), aprenderemos cómo utilizar la afinidad de nodo 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 iniciarse 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 etiquetas (labels)

En este paso, crearemos un nodo con una etiqueta (label) que se utilizará para programar pods.

1. Crea un archivo llamado node-with-label.yaml con el siguiente contenido en el directorio /home/labex:

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

2. Aplica los cambios:

kubectl apply -f node-with-label.yaml

3. Verifica que el nodo se haya creado y etiquetado:

kubectl get nodes --show-labels

Crear un pod con afinidad de nodo (node affinity)

En este paso, crearemos un pod con una regla de afinidad de nodo (node affinity) que garantizará que se programe en un nodo con una etiqueta (label) específica.

1. Crea un archivo llamado pod-with-node-affinity.yaml con el siguiente contenido en el directorio /home/labex:

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

2. Aplica los cambios:

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

3. Verifica que el pod se haya programado en el nodo con la etiqueta (label) type=web:

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

Crear un pod con anti-afinidad de nodo (node anti - affinity)

En este paso, crearemos un pod con una regla de anti-afinidad de nodo (node anti - affinity) que garantizará que no se programe en un nodo con una etiqueta (label) específica.

1. Crea un archivo llamado pod-with-node-anti-affinity.yaml con el siguiente contenido en el directorio /home/labex:

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

2. Aplica los cambios:

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

3. Verifica que el pod no se haya programado en el nodo con la etiqueta (label) type=db:

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

Crear un pod con afinidad de nodo (node affinity) y selector de nodo (node selector)

En este paso, crearemos un pod con una regla de afinidad de nodo (node affinity) y un selector de nodo (node selector) que garantizarán que se programe en un nodo con una etiqueta (label) específica.

1. Crea un archivo llamado pod-with-node-affinity-and-selector.yaml con el siguiente contenido en el directorio /home/labex:

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

2. Aplica los cambios:

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

3. Verifica que el pod no se haya programado en el nodo con la etiqueta (label) type=web:

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

Crear un pod con múltiples reglas de afinidad de nodo (node affinity)

En este paso, crearemos un pod con múltiples reglas de afinidad de nodo (node affinity) que garantizarán que se programe en un nodo con etiquetas (labels) que cumplan con todas las reglas.

1. Crea un archivo llamado pod-with-multiple-node-affinity.yaml con el siguiente contenido en el directorio /home/labex:

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

2. Aplica los cambios:

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

3. Verifica que el pod se haya programado en el nodo con las etiquetas (labels) type=web y disktype=ssd:

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

Resumen

En este laboratorio, aprendimos cómo usar la afinidad de nodo (node affinity) para programar pods en nodos específicos. Creamos un nodo con una etiqueta (label) y luego creamos pods con reglas de afinidad de nodo (node affinity) que garantizaron que se programaran en nodos con etiquetas específicas. También creamos un pod con una regla de anti-afinidad de nodo (node anti - affinity) que garantizó que no se programara en un nodo con una etiqueta específica. Finalmente, creamos un pod con múltiples reglas de afinidad de nodo (node affinity) que garantizó que se programara en un nodo con etiquetas que cumplieran con todas las reglas.