Kubernetes: corrupción y tolerancia

Un pod es un grupo de uno o más contenedores y es la unidad implementable más pequeña en Kubernetes. Un Node es una representación de una sola máquina en un clúster (simplemente podemos ver estas máquinas como un conjunto de CPU y RAM). Un Node puede ser una máquina virtual, una máquina física en un centro de datos alojado en un proveedor de nube como Azure. 

Cuando un usuario ejecuta el comando de creación de pod indicado a continuación, la solicitud se envía al servidor API. El programador siempre está observando el servidor API en busca de nuevos eventos, identificó los pods no asignados y decide qué Node debe elegir para implementar este pod en función de varios factores, como el selector de Nodes, las contaminaciones/tolerancias, la afinidad del Node, los requisitos de CPU y memoria, etc. Una vez que se decide el Node y se envía al servidor API, kubelet se asegura de que el pod se esté ejecutando en el Node asignado.

kubectl (client ): kubectl create -f <pod-yaml-file-path> 

Necesidad de corrupción y tolerancia:

Nodes con hardware diferente : si tiene un Node que tiene hardware diferente (ejemplo: GPU) y desea programar solo los pods que necesitan GPU. Ejemplo: Considere que hay 2 aplicaciones APLICACIÓN 1: Una aplicación de tablero simple y APLICACIÓN 2: Una aplicación de uso intensivo de datos, ambas tienen diferentes requisitos de CPU y memoria. APP1 no requiere mucha memoria y CPU, mientras que APP 2 necesita mucha memoria y CPU (máquina GPU). Ahora, con la ayuda de contaminaciones y tolerancias + afinidad de Node, podemos asegurarnos de que APP 2 se implemente en un Node que tenga mucha CPU y memoria, mientras que APP1 se puede programar en cualquier Node con poca CPU y memoria.

Limite la cantidad de pods en un Node: si desea que un Node programe una cierta cantidad de pods para reducir la carga en ese Node, Taints/Tolerations + Node Affinity puede ayudarnos a lograrlo. Ejemplo: Considere que hay un pod que consta de una aplicación de base de datos que debe ser rápida en las consultas de datos y altamente disponible. Por lo tanto, dedicaremos un Node con mucha memoria y CPU para este módulo. Ahora el Node tendrá solo un pod, lo que hace que sea más rápido y eficiente usar los recursos del Node. 

• La afinidad de Nodes garantiza que los pods estén programados en Nodes particulares. 
• Las corrupciones son lo opuesto a la afinidad de Nodes; permiten que un Node rechace un conjunto de vainas. 
• La tolerancia se aplica a los pods y permite (pero no requiere) que los pods se programen en Nodes con taints coincidentes.

Entendamos esto con un ejemplo: Consideremos que hay una Persona N1 y un Mosquito P1. Ejemplo de contaminación: la persona N1 aplicó un repelente (contaminación), por lo que ahora el mosquito P1 no podrá atacar a la persona N1. Ahora supongamos que hay Wasp P2 que intenta atacar a la Persona N1

Ejemplo de Tolerancia: La Avispa P2 es tolerante al repelente, por lo tanto no tiene efecto y una Persona N1 sería atacada. Aquí 2 cosas deciden si un mosquito o una avispa pueden aterrizar en una persona: Mancha (Repelente) del Mosquito P1 y Tolerancia de la Avispa P2

En el mundo de Kubernetes, Persons corresponde a Nodes, y Mosquito y Wasp corresponden a Pods. 

Ejemplo  

Caso 1: Mancha Node 1 (Azul)

Dado que no se toleran pods, ninguno de ellos se programaría en el Node 1

Caso 2: agregamos tolerancia al pod D. Ahora solo el pod D podrá programar en el Node 1

Manchas y tolerancias

Las corrupciones son una propiedad de los Nodes que alejan los pods si no toleran la corrupción del Node. Al igual que las etiquetas, se pueden aplicar múltiples contaminaciones a un Node. 

¿Cómo podemos permitir que ciertos pods se programen en Nodes contaminados? 

 Al especificar qué pods son tolerantes a una contaminación específica; agregamos tolerancias a ciertos pods.

Las tolerancias se establecen en los pods y permiten que los pods se programen en Nodes con taints coincidentes. Las corrupciones y las tolerancias no tienen nada que ver con la seguridad.

Sintaxis: 

kubectl taint nodes node-name key=value:taint-effect 

Efecto de mancha:

• NoSchedule : los pods no se programarán en el Node a menos que sean tolerantes. Los pods no se programarán, pero si ya se están ejecutando, no lo eliminarán. No se programan más pods nuevos en este Node si no coincide con todas las contaminaciones de este Node.
• PreferNoSchedule : el programador preferirá no programar un pod en el Node corrupto, pero no hay garantía. Significa que el Programador intentará no colocar un Pod que no tolere la corrupción en el Node, pero no es obligatorio.
• NoExecute : tan pronto como se aplique la contaminación NoExecute a un Node, todos los pods existentes serán desalojados sin coincidir con la tolerancia del Node.

Ejemplo del efecto NoExecute Taint:

Actualmente, ninguna de las vainas es tolerante al azul.

Archivo Pod D YAML:

• Línea 1-2: v1 de la API de Kubernetes Pod. Por tipo, Kubernetes sabe qué componente crear.                                                                                    
• Línea 3-4: los metadatos brindan información que no influye en el comportamiento del pod, se usan para definir el nombre del pod y algunas etiquetas (que los controladores usarán más adelante)                                                                                                                                                                                                       
• Línea 5: especificación definimos contenedores aquí. El pod puede tener varios contenedores.                                                                                                                       
• Línea 6-8: el nombre del contenedor aquí es redis-container, la imagen Redis se extraerá del registro del contenedor.                                                                           
• Línea 7: el valor predeterminado del operador es Igual. Una tolerancia «coincide» con una corrupción si las claves son las mismas y los efectos son los mismos, y: operador = Existe (en cuyo caso no se debe especificar ningún valor). operador = Igual y los valores son iguales. Si las claves están vacías y el operador existe, entonces coincide con todas las claves y valores (es decir, tolerará todo el efecto es el tipo de efecto de contaminación, aquí elegimos el efecto NoExecute 

Ahora tiñe el Node 1 a azul 

kubectl taint nodes node1 app=blue:NoExecute

Aquí, node1 -> nombre del Node en el que se aplicará la corrupción. La aplicación=azul:NoExecute –> par clave-valor: Tipo de efecto de corrupción. Esto significa que todos los pods existentes que no toleren la corrupción serán desalojados.

El Pod C será desalojado del Node 1, ya que no tolera la contaminación azul. 

En el ejemplo anterior, el Node D se programó en el Node 1. ¿Qué sucede si se programó en otro Node? Es posible ?

Sí

Taints/Tolerations + Node Affinity = Garantiza que un pod específico solo se puede programar en un Node específico y que no se pueden programar otros pods en Nodes contaminados. Ejemplo o

Nota: El Node principal no tiene ningún pod. Porque cuando se crea el clúster, Kubernetes contamina su Node principal, por lo que no se programan pods en el Node principal.

kubectl describe node kubemaster | grep Taints

Producción: