Kubernetes Basics · Lección

Selectores y afinidad de nodos

Controle dónde se programan los Pods mediante selectores de nodos y reglas más expresivas de afinidad entre nodos y Pods.

Selectores y afinidad de nodos es una lección gratuita de Kubernetes Basics en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kubernetes Basics, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kubernetes Basics incluye 4 lecciones en total.

Controle dónde se ejecutan los Pods

De forma predeterminada, Kubernetes planifica los Pods en cualquier nodo disponible. Pero ¿qué ocurre si necesita tener más control?

A veces, necesita que los Pods se ejecuten en nodos específicos. Quizá esos nodos tengan hardware especial, licencias concretas o se encuentren en determinadas zonas de disponibilidad.

En esta lección se explica cómo orientar el planificador de Kubernetes mediante selectores de nodos y afinidad de nodos.

¿Por qué orientar al planificador?

Imagine que tiene un Pod de base de datos que debe ejecutarse en un nodo con SSD de alto rendimiento, o una aplicación con un uso intensivo de GPU que requiere hardware específico.

También puede querer mantener determinados Pods separados por motivos de tolerancia a fallos o asegurarse de que se ejecuten en nodos con sistemas operativos concretos.

Kubernetes proporciona herramientas para expresar estas preferencias de planificación.

Los nodos tienen etiquetas

Antes de indicar a los Pods dónde deben ejecutarse, los nodos necesitan una identidad. Kubernetes utiliza etiquetas para identificar los nodos según sus características.

Las etiquetas son pares clave-valor, como disk=ssd o gpu=true.
Puede añadir etiquetas personalizadas a sus nodos mediante kubectl label nodes <node-name> <key>=<value>.
Estas etiquetas permiten seleccionar nodos específicos para colocar los Pods.

Selectores de nodos: coincidencia simple

La forma más sencilla de restringir un Pod a un conjunto específico de nodos es utilizar nodeSelector.

Es un campo de la especificación del Pod que recibe un mapa de pares clave-valor. El Pod solo se planificará en nodos que tengan todas esas etiquetas.

Es como decir: «Necesito un nodo que sea exactamente así».

Selector de nodos en acción

Supongamos que tenemos nodos etiquetados con disk=ssd. Así puede hacer que un Pod se ejecute únicamente en esos nodos:

apiVersion: v1
kind: Pod
metadata:
  name: ssd-app
spec:
  containers:
  - name: my-container
    image: nginx
  nodeSelector:
    disk: ssd

Afinidad de nodos: coincidencia avanzada

Aunque nodeSelector es sencillo, también es muy estricto. ¿Qué ocurre si quiere utilizar nodos «preferidos» o reglas de coincidencia más complejas?

La afinidad de nodos ofrece más flexibilidad. Permite expresar requisitos «flexibles» o «estrictos» para que los Pods se ejecuten en nodos con etiquetas específicas.

Utiliza una sintaxis más potente, con operadores como In, NotIn, Exists, DoesNotExist, Gt y Lt.

Afinidad obligatoria y preferida

La afinidad de nodos tiene dos tipos principales:

requiredDuringSchedulingIgnoredDuringExecution: el Pod debe planificarse en un nodo que cumpla las reglas. Si no existe ningún nodo de ese tipo, el Pod no se planificará.
preferredDuringSchedulingIgnoredDuringExecution: el planificador intenta encontrar un nodo que cumpla las reglas, pero si no hay ninguno disponible, planificará el Pod en otro lugar. Es un enfoque de «mejor esfuerzo».

Afinidad de nodos obligatoria

Este es un Pod que requiere un nodo con la etiqueta env=production. Si no existe ningún nodo de ese tipo, el Pod permanecerá pendiente.

apiVersion: v1
kind: Pod
metadata:
  name: prod-app
spec:
  containers:
  - name: my-container
    image: httpd
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: env
            operator: In
            values:
            - production

Afinidad de Pods: otros Pods importan

¿Qué ocurre si quiere planificar los Pods según dónde se estén ejecutando otros Pods?

Afinidad de Pods: atrae los Pods a nodos donde ya se estén ejecutando otros Pods con etiquetas específicas. Es útil para colocar juntos servicios que se comunican con frecuencia.
Antiafinidad de Pods: aleja los Pods de los nodos donde se estén ejecutando otros Pods con etiquetas específicas. Es ideal para distribuir réplicas entre nodos y obtener una alta disponibilidad.

Antiafinidad de Pods en la práctica

Este manifiesto garantiza que no se puedan planificar dos Pods con la etiqueta app=my-web en el mismo nodo. Esto mejora la tolerancia a fallos.

topologyKey especifica el dominio en el que se aplica la antiafinidad (por ejemplo, nodo o zona).

apiVersion: v1
kind: Pod
metadata:
  name: web-app-pod
  labels:
    app: my-web
spec:
  containers:
  - name: web-container
    image: busybox
    command: ["sh", "-c", "echo 'Hello from web-app'; sleep 3600"]
  affinity:
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - labelSelector:
            matchLabels:
              app: my-web
          topologyKey: "kubernetes.io/hostname"

Compruebe sus conocimientos

Quiere asegurarse de que sus Pods de base de datos críticos no se planifiquen nunca en nodos con la etiqueta zone=dev. ¿Qué tipo de regla de planificación utilizaría para esta exclusión estricta basada en etiquetas de nodo?

Resumen: control de la planificación

¡Buen trabajo! Ha aprendido formas potentes de controlar dónde se ejecutan sus Pods:

Etiquetas de nodos: pares clave-valor que identifican las características de los nodos.
Selectores de nodos: coincidencia sencilla y estricta para planificar Pods en nodos con etiquetas específicas.
Afinidad de nodos: reglas más flexibles (obligatorias o preferidas) para seleccionar nodos mediante operadores.
Afinidad y antiafinidad de Pods: colocar juntos o separar Pods según la ubicación de otros Pods.

Estas herramientas son fundamentales para optimizar el uso de los recursos, garantizar la tolerancia a fallos y satisfacer las necesidades específicas de las aplicaciones.

Preguntas frecuentes

¿La lección «Selectores y afinidad de nodos» es gratis?

Sí — el texto completo de «Selectores y afinidad de nodos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kubernetes Basics, actualiza a CoddyKit PRO. El curso de Kubernetes Basics incluye 4 lecciones en total.

¿Qué aprenderé en «Selectores y afinidad de nodos»?

Controle dónde se programan los Pods mediante selectores de nodos y reglas más expresivas de afinidad entre nodos y Pods. Practicas Kubernetes Basics con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kubernetes Basics?

No se requiere experiencia previa. Kubernetes Basics en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Selectores y afinidad de nodos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kubernetes Basics?

Sí. Cada lección de Kubernetes Basics incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Kubernetes Basics