L'affinité de nœud est un ensemble de règles. Il est utilisé par le planificateur pour décider où un pod peut être placé dans le cluster. Les règles sont définies à l'aide d'étiquettes sur les nœuds et de sélecteurs d'étiquettes spécifiés dans la définition des pods. L'affinité de nœud permet à un pod de spécifier une affinité avec un groupe de nœuds sur lesquels il peut être planifié. Nous pouvons limiter un pod pour qu'il ne puisse s'exécuter que sur un ou plusieurs nœuds particuliers.
nodeSelector est la forme la plus simple de contrainte de sélection de nœud. nodeSelector est une propriété de PodSpec. Pour que le pod puisse être exécuté sur un nœud, le nœud doit avoir chacun des libellés indiqués.
L'affinité de nœud est conceptuellement similaire à nodeSelector :elle nous permet de limiter les nœuds sur lesquels notre pod peut être planifié, en fonction des étiquettes sur le nœud.
Il existe actuellement deux types d'affinité de nœud,
- requiredDuringSchedulingIgnoredDuringExecution et
- preferredDuringSchedulingIgnoredDuringExecution.
Qu'est-ce que pendant la planification
- Ici, le module n'est pas encore créé et va être créé pour la première fois.
- Généralement, lorsque le pod est créé, les règles d'affinité seront appliquées.
Qu'est-ce que l'exécution pendant l'exécution ?
- Ici, le pod a été exécuté et la modification est apportée à l'environnement qui affecte nodeAffinity.
Pour connaître Node Affinity en détail, visitez kubernete.io la documentation officielle de Kubernetes.
Dans cet article, nous verrons comment attribuer un pod Kubernetes à un nœud particulier à l'aide de l'affinité de nœud "requiredDuringSchedulingIgnoredDuringExecution" dans un cluster Kubernetes.
Pré-requis
- Cluster Kubernetes avec au moins 1 nœud de travail.
Si vous souhaitez apprendre à créer un cluster Kubernetes, cliquez ici. Ce guide vous aidera à créer un cluster Kubernetes avec 1 maître et 2 nœuds sur les instances AWS Ubuntu 18.04 EC2.
Qu'allons-nous faire ?
- Configurer l'affinité de nœud
Configurer l'affinité de nœud
Tout d'abord, obtenons une liste des nœuds disponibles dans le cluster.
kubectl get nodes #Get all the nodes in the cluster
Vérifiez si les nœuds contiennent des souillures.
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
Ajoutez une étiquette à un nœud de travail node01.
kubectl label node node01 app=qa #Add a label
Créez un fichier de définition de déploiement et ajoutez-y la définition suivante.
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
Obtenez une liste des pods et des déploiements.
kubectl get pods #Get pods in the default namespace
kubectl get deployment #Get deployments in the default namespace
Créez un déploiement à partir de la définition que nous avons créée.
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
Obtenez des détails sur les pods créés par le déploiement.
Ici, on peut voir que les pods obtiennent également des places dans le nœud maître. La raison en est que les nœuds n'ont pas de souillure sur eux, donc les pods peuvent obtenir des places sur n'importe lequel des nœuds disponibles.
kubectl get pods -o wide #Get pods in the default namespace with more information about them using -o wide
Maintenant, créez une définition de déploiement avec une affinité de nœud définie.
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
Obtenez une liste des déploiements existants et créez un nouveau déploiement avec affinité à l'aide du fichier créé à l'étape ci-dessus.
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
Maintenant, on peut voir que les pods ont cette fois été placés sur le nœud de travail node01 uniquement. La raison en est que nous avons défini une affinité de nœud dans la définition de déploiement qui garantit que les pods sont déployés sur les nœuds correspondant à la condition/étiquette définie.
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
Conclusion
Dans cet article, nous avons appris à ajouter des étiquettes aux nœuds et vu comment les pods peuvent être limités pour être programmés sur les nœuds requis à l'aide de l'affinité de nœud. Nous avons également vu que les pods peuvent même être déployés sur le nœud maître s'il n'y a pas de rejet.