Usar afinidad de nodos en Kubernetes

La afinidad de nodos es un conjunto de reglas. El programador lo utiliza para decidir dónde se puede colocar un pod en el clúster. Las reglas se definen mediante etiquetas en los nodos y selectores de etiquetas especificados en la definición de los pods. La afinidad de nodos permite que un pod especifique una afinidad hacia un grupo de nodos en los que se puede programar. Podemos limitar un Pod para que solo pueda ejecutarse en un Nodo(s) en particular.

nodeSelector es la forma más simple de restricción de selección de nodos. nodeSelector es una propiedad de PodSpec. Para que el pod pueda ejecutarse en un nodo, el nodo debe tener cada una de las etiquetas indicadas.

La afinidad de nodos es conceptualmente similar a nodeSelector --nos permite limitar en qué nodos puede programarse nuestro pod, según las etiquetas del nodo.

Actualmente hay dos tipos de afinidad de nodos, 

1. requerido durante la programación ignorado durante la ejecución y 
2. preferido durante la programación ignorado durante la ejecución.

Qué es durante la programación

• Aquí, el pod aún no se ha creado y se creará por primera vez.
• Por lo general, cuando se crea el pod, se aplicarán las reglas de afinidad.

Qué es durante la ejecución

• Aquí, el pod se ha estado ejecutando y el cambio se ha realizado en el entorno que afecta a nodeAffinity.

Para conocer Node Affinity en detalle, visite kubernete.io la documentación oficial de Kubernetes.

En este artículo, veremos cómo asignar un pod de Kubernetes a un nodo en particular usando la afinidad de nodo "requiredDuringSchedulingIgnoredDuringExecution" en un clúster de Kubernetes.

Requisitos previos

1. Clúster de Kubernetes con al menos 1 nodo trabajador.
   Si desea aprender a crear un clúster de Kubernetes, haga clic aquí. Esta guía lo ayudará a crear un clúster de Kubernetes con 1 maestro y 2 nodos en instancias AWS Ubuntu 18.04 EC2.

¿Qué haremos?

1. Configurar afinidad de nodos

Configurar afinidad de nodos

En primer lugar, obtengamos una lista de nodos disponibles en el clúster.

kubectl get nodes #Get all the nodes in the cluster

Comprueba si los nodos tienen Manchas.

kubectl describe node node01 | grep Taints #Describe the node node01 and grep Taints

kubectl describe node master | grep Taints #Describe the node master and grep Taints

Agregue una etiqueta a un nodo trabajador node01.

kubectl label node node01 app=qa #Add a label

Cree un archivo de definición de implementación y agregue la siguiente definición en él.

vim my-deployment-without-affinity.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-without-affinity
spec:
  replicas: 20
  selector:
    matchLabels:
      run: nginx
  template:
    metadata:
      labels:
        run: nginx
    spec:
      containers:
      - image: nginx
        imagePullPolicy: Always
        name: nginx

Obtenga una lista de pods e implementaciones.

kubectl get pods #Get pods in the default namespace

kubectl get deployment #Get deployments in the default namespace

Cree una implementación a partir de la definición que creamos.

kubectl create -f my-deployment-without-affinity.yml #Create a deployment object

kubectl get deployment #Get deployments in the default namespace

kubectl get pods #Get pods in the default namespace

Obtenga detalles de los pods creados por la implementación.

Aquí se puede ver que los Pods también están obteniendo lugares en el nodo maestro. La razón de esto es que los nodos no tienen Manchas, por lo que los pods pueden obtener lugares en cualquiera de los nodos disponibles.

kubectl get pods -o wide #Get pods in the default namespace with more information about them using -o wide

Ahora, cree una definición de implementación con afinidad de nodo definida.

vim my-deployment-with-affinity.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-with-afiinity
spec:
  replicas: 6
  selector:
    matchLabels:
      run: nginx
  template:
    metadata:
      labels:
        run: nginx
    spec:
      containers:
      - image: nginx
        imagePullPolicy: Always
        name: nginx
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: app
                operator: In
                values:
                - qa

Obtenga una lista de implementaciones existentes y cree una nueva implementación con afinidad usando el archivo creado en el paso anterior.

kubectl get deployments #Get deployments in the default namespace

kubectl create -f my-deployment-with-affinity.yml #Create a deployment object

kubectl get deployments #Get deployments in the default namespace

Ahora, se puede ver que los Pods esta vez se colocaron solo en el nodo de trabajo node01. La razón de esto es que definimos una afinidad de nodo en la definición de implementación que garantiza que los pods se implementen en los nodos que coincidan con la condición/etiqueta definida.

kubectl  get pods -o wide | grep app-with-afiinity #Get pods in the default namespace with more information about them using -o wide and grep app-with-afiinity

Conclusión

En este artículo, aprendimos a agregar etiquetas a los nodos y vimos cómo se pueden restringir los pods para que se programen en los nodos necesarios mediante Node Affinity. También vimos que los pods pueden incluso implementarse en el nodo principal si no tiene ninguna corrupción.