- Simplificando Kubernetes
- Día 12: Dominando Taints y Tolerations
- Contenido del Día 12
- DÍA 12+1: Comprendiendo y Dominando los Selectores
¡Hola a todos! En el capítulo de hoy, vamos a sumergirnos profundamente en uno de los conceptos más poderosos y flexibles de Kubernetes: Taints (Marcas) y Tolerations (Tolerancias). Prepárense, porque este capítulo va más allá de lo básico y entra en detalles que no querrán perderse. #VAMOS
Los Taints son "manchas" o "marcas" aplicadas a los Nodos que los marcan para evitar que ciertos Pods sean programados en ellos. Por otro lado, las Tolerations son configuraciones que se pueden aplicar a los Pods para permitir que sean programados en Nodos con Taints específicos.
En un clúster Kubernetes diverso, no todos los Nodos son iguales. Algunos pueden tener acceso a recursos especiales como GPUs, mientras que otros pueden estar reservados para cargas de trabajo críticas. Los Taints y Tolerations proporcionan un mecanismo para asegurar que los Pods se programen en los Nodos adecuados.
Un Taint está compuesto por una clave, un valor y un efecto. El efecto puede ser:
NoSchedule: Kubernetes no programa el Pod a menos que tenga una Tolerations correspondiente.PreferNoSchedule: Kubernetes intenta no programar, pero no hay garantía.NoExecute: Los Pods existentes son eliminados si no tienen una Tolerations correspondiente.
Una Tolerations se define mediante los mismos elementos que un Taint: clave, valor y efecto. Además, contiene un operador, que puede ser Equal o Exists.
Para aplicar un Taint a un Nodo, puedes utilizar el comando kubectl taint. Por ejemplo:
kubectl taint nodes nodo1 clave=valor:NoScheduleLas Tolerations se configuran en el PodSpec. Aquí tienes un ejemplo:
apiVersion: v1
kind: Pod
metadata:
name: my-pod
spec:
tolerations:
- key: "key"
operator: "Equal"
value: "value"
effect: "NoSchedule"Imagina un escenario en el que tienes Nodos que deben estar dedicados a cargas de trabajo de producción y no deben ejecutar Pods de desarrollo.
Aplicación de Taint:
kubectl taint nodes prod-node environment=production:NoScheduleTolerancia en el Pod de producción:
tolerations:
- key: "environment"
operator: "Equal"
value: "producción"
effect: "NoSchedule"Si tienes Nodos con GPUs y deseas asegurarte de que solo se programen Pods que necesiten GPUs allí.
Aplicación de Taint:
kubectl taint nodes gpu-node gpu=true:NoScheduletolerations:
- key: "gpu"
operator: "Equal"
value: "true"
effect: "NoSchedule"Si necesitas realizar mantenimiento en un Nodo y deseas evitar que se programen nuevos Pods en él.
Aplicar Taint:
kubectl taint nodes node1 maintenance=true:NoExecutePuedes combinar Taints y Tolerations con reglas de afinidad para un control aún más granular.
Creemos un Nodo con un Taint y tratemos de programar un Pod sin la Toleration correspondiente.
# Aplicar Taint
kubectl taint nodes dev-node environment=development:NoSchedule
# Intentar programar el Pod
kubectl run nginx --image=nginxObserva que el Pod no se programará hasta que se agregue una Toleration correspondiente.
Creemos un Nodo con una GPU y apliquemos un Taint correspondiente.
# Aplicar Taint
kubectl taint nodes gpu-node gpu=true:NoSchedule
# Programar Pod con Toleration
kubectl apply -f gpu-pod.yamlDonde gpu-pod.yaml contiene la Toleration correspondiente.
Simulemos un mantenimiento aplicando un Taint a un Nodo y observemos cómo se eliminan los Pods.
# Aplicar Taint
kubectl taint nodes node1 maintenance=true:NoExecuteEstos ejemplos prácticos te ayudarán a comprender mejor cómo funcionan los Taints y Tolerations en situaciones del mundo real.
Taints y Tolerations son herramientas poderosas para un control refinado de la programación de Pods. Con ellas, puedes aislar workloads, aprovechar hardware especializado e incluso gestionar el mantenimiento de manera más eficaz.
- Aplica un Taint en uno de tus Nodos y trata de programar un Pod sin la Toleration correspondiente.
- Elimina el Taint y observa el comportamiento.
- Agrega una Toleration al Pod y repite el proceso.
¡Hola a todos! En el capítulo de hoy, profundizaremos en uno de los recursos más versátiles y fundamentales de Kubernetes: los Selectores. ¿Están listos? ¡Entonces #VAMOS!
Los Selectors son formas de seleccionar recursos, como Pods, en función de sus etiquetas. Son el pegamento que une varios componentes de Kubernetes, como Services y RéplicaSets.
Estos son los más simples y utilizan operadores como =, == y !=.
Ejemplo:
kubectl get pods -l environment=productionEstos son más complejos y utilizan operadores como in, notin y exists.
Ejemplo:
kubectl get pods -l 'environment in (production, qa)'Los Services utilizan selectores para dirigir el tráfico hacia Pods específicos.
Ejemplo:
apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
selector:
app: MyAppLos ReplicaSets utilizan selectores para saber qué Pods gestionar.
Ejemplo:
apiVersion: apps/v1
kind: ReplicaSet
metadata:
name: my-replicaset
spec:
selector:
matchLabels:
app: MyAppLos Jobs y CronJobs también pueden utilizar selectores para ejecutar tareas en Pods específicos.
Es crucial entender que los selectores no atraviesan namespaces; son efectivos solo dentro del namespace actual a menos que se especifique de otra manera.
Utilice Selectors en los Services para dirigir el tráfico hacia versiones específicas de una aplicación.
Utilice selectores en Horizontal Pod Autoscalers para escalar solo los Pods que cumplan con criterios específicos.
En casos de conmutación por error, puede utilizar selectores para dirigir el tráfico hacia Pods en un clúster secundario.
- No cambie las etiquetas de los Pods que son objetivos de Services sin actualizar el selector del Service.
- Utilice selectores de manera consistente para evitar confusiones.
Vamos a crear un Service que seleccione todos los Pods con la etiqueta frontend.
kubectl apply -f frontend-service.yamlVamos a crear un ReplicaSet que gestione todos los Pods con la etiqueta backend.
kubectl apply -f backend-replicaset.yamlVamos a realizar una consulta compleja para seleccionar Pods basados en múltiples etiquetas.
kubectl get pods -l 'release-version in (v1, v2),environment!=debug'Los selectores son una herramienta poderosa y flexible en Kubernetes, que permite un control preciso sobre cómo interactúan los recursos. Dominar este concepto es fundamental para cualquiera que trabaje con Kubernetes.