Programación con afinidad de nodos

Introducción

En Kubernetes, la afinidad de nodos (node affinity) se utiliza para programar pods en nodos que cumplen ciertas condiciones. Esto permite asegurar que los pods se ejecuten en tipos específicos de nodos o equilibrar la carga de trabajo entre ellos. En este laboratorio, aprenderemos a utilizar la afinidad de nodos para programar pods en nodos específicos.

Iniciar el clúster de Minikube

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

Navega a tu directorio de trabajo:

Abre la terminal y dirígete a la carpeta del proyecto predeterminada:
```
cd /home/labex/project
```
Inicia 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.
Verifica 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.
- 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.

Ejecuta los pasos restantes de este laboratorio desde /home/labex/project para que los archivos YAML permanezcan en el mismo directorio de trabajo.

Crear un nodo con etiquetas

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

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

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

Aplica los cambios:

kubectl apply -f node-with-label.yaml

Verifica que el nodo se haya creado y etiquetado correctamente:

kubectl get nodes --show-labels

Crear un pod con afinidad de nodos

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

Crea un archivo llamado pod-with-node-affinity.yaml con el siguiente contenido en el directorio /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

Aplica los cambios:

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

Verifica que el pod esté programado en el nodo con la etiqueta type=web:

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

Crear un pod con anti-afinidad de nodos

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

Crea un archivo llamado pod-with-node-anti-affinity.yaml con el siguiente contenido en el directorio /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

Aplica los cambios:

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

Verifica que el pod no esté programado en el nodo con la etiqueta type=db (o que se haya evitado la etiqueta web):

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

Crear un pod con afinidad de nodos y selector de nodos

En este paso, crearemos un pod que utiliza tanto una regla de afinidad de nodos como un selector de nodos para asegurar que se programe en un nodo con una etiqueta específica.

Crea un archivo llamado pod-with-node-affinity-and-selector.yaml con el siguiente contenido en el directorio /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

Aplica los cambios:

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

Verifica el estado del pod (observa cómo el conflicto entre el selector y la afinidad afecta la programación):

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

Crear un pod con múltiples reglas de afinidad de nodos

En este paso, crearemos un pod con múltiples reglas de afinidad de nodos que garantizarán que se programe en un nodo cuyas etiquetas coincidan con todas las reglas definidas.

Crea un archivo llamado pod-with-multiple-node-affinity.yaml con el siguiente contenido en el directorio /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

Aplica los cambios:

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

Verifica que el pod esté programado en el nodo que cumple con las etiquetas type=web y disktype=ssd:

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

Resumen

En este laboratorio, aprendimos a utilizar la afinidad de nodos para programar pods en nodos específicos. Creamos un nodo con una etiqueta y luego configuramos pods con reglas de afinidad que aseguraron su ubicación en nodos con etiquetas determinadas. También creamos un pod con una regla de anti-afinidad para evitar nodos específicos y, finalmente, un pod con múltiples reglas de afinidad que debían cumplirse simultáneamente.