Que sont les tolérances et les rejets dans Kubernetes ?
La tolérance et le rejet dans Kubernetes sont utilisés pour garantir que les pods sont placés dans le bon nœud. La tolérance est définie dans la spécification du pod tandis que les rejets sont définis dans la spécification du nœud. Lorsque vous appliquez la tolérance sur un pod, cela permet au planificateur de planifier les pods sur un nœud spécifique. Cependant, les souillures fonctionnent à l'opposé de la tolérance. Il permet au nœud de rejeter les pods à programmer sur celui-ci. Les pods ne sont autorisés à être programmés sur le nœud que si des tolérances leur sont appliquées avec des rejets correspondants.
Kubernetes fonctionne avec des pods, des clusters, des nœuds, des événements, etc. Dans certains cas, pour gérer ces éléments, Kubernetes a besoin de tolérances et de rejets. La tolérance est la mise en œuvre du processus d'ordonnancement. Les pods doivent être programmés afin qu'ils puissent fonctionner correctement et qu'ils puissent disposer de suffisamment de ressources en cas de besoin pour effectuer leur opération. Des tolérances sont appliquées aux gousses contre les salissures afin qu'elles ne subissent aucune interruption ou perturbation pendant le travail.
Les rejets dans Kubernetes permettent à un pod de rejeter la planification d'un pod. Il est appliqué à un nœud en utilisant la spécification de nœud « NodeSpec ». Le planificateur n'est pas en mesure de placer un pod sur un nœud qui contient une marque. Cependant, si vous devez planifier les pods sur un nœud où une teinte est déjà appliquée, vous devez déclarer la tolérance par rapport à celui-ci.
La tolérance dans Kubernetes permet à un pod d'être planifié sur un nœud où une teinte est déjà appliquée. La tolérance sur un pod est appliquée à l'aide de la spécification de pod 'PodSpec'. Lorsque vous appliquez la tolérance sur un pod avec une teinte correspondante, le planificateur peut facilement planifier les pods sur un nœud spécifique.
Maintenant, laissez-nous vous présenter un scénario pour vous aider à comprendre comment vous pouvez implémenter la tolérance sur un pod dans Kubernetes. Avant de passer à la section de mise en œuvre, assurez-vous que vous disposez de toutes les conditions préalables.
Prérequis:
Voici les éléments dont vous avez besoin pour implémenter la tolérance sur un nœud dans Kubernetes :
- Ubuntu 20.04 ou toute autre version la plus récente de tout système Linux
- Minikube (dernière version)
- Machine virtuelle installée dans votre système Linux/Unix
- Outil de ligne de commande Kubectl
En supposant que votre système réponde à tous les besoins de prérequis, commençons à définir la tolérance de Kubernetes.
Étape 1 : Démarrez le terminal Minikube
La première chose que vous devez faire est de démarrer le terminal minikube afin de pouvoir utiliser les commandes kubectl pour la mise en œuvre de la tolérance Kubernetes sur un nœud. Pour démarrer le minikube, la commande suivante est utilisée :
> commencer minikubeLors de l'exécution de cette commande, vous obtenez la sortie suivante dans votre terminal :
Étape 2 : Obtenir la liste des nœuds actifs
Maintenant que nous avons démarré le minikube, notre système est prêt à définir la tolérance sur les pods dans Kubernetes. Avant de définir la tolérance sur les pods, vérifions combien de nœuds et quel type de nœuds nous avons déjà. Pour ce faire, nous utilisons la commande suivante suivante :
> kubectl obtenir des nœuds -Les =custom-columns=NodeName :.metadata.name,TaintKey :.spec.taints [ * ] .key,TaintValue :.spec.taints [ * ] .value,TaintEffect:.spec.taints [ * ] .effetCette instruction répertorie tous les nœuds qui sont entachés par l'installation par défaut de Kubernetes. Voyons d'abord la sortie de cette commande. Ensuite, nous discutons de la liste des nœuds :
Étant donné qu'aucun nœud n'est créé et entaché par l'installation par défaut de Kubernetes et que nous n'avons pas spécifiquement créé de nœud, le résultat est
Étape 3 : Créer un espace de noms
Tout d'abord, nous créons un espace de noms pour déployer une application sur un cluster. Ici, nous créons une application avec la valeur 'frontend' à l'aide de la commande suivante :
> kubectl créer une interface nsCette commande crée l'espace de noms ayant la valeur 'frontend'. Voir la sortie suivante :
Étape 4 : Déployer le pod Nginx sur l'espace de noms
Maintenant, déployez le pod nginx sur l'espace de noms que nous venons de créer. Nous utilisons la commande suivante pour déployer le nginx :
> kubectl exécuter nginx – image =nginx –interface d'espace de nomsCela déploie une application sur un cluster sans configuration de tolérance dans la spécification du déploiement de l'application. À l'aide de la commande kubectl, nous déployons le pod nginx sur l'interface de l'espace de noms :
Étape 5 : Obtenir la liste des pods
Maintenant, vérifions les pods créés pour voir leurs statuts. La commande donnée répertorie également tous les pods et leurs statuts :
> kubectl obtenir des pods -n l'extrémité avantPuisque nous n'avons créé que le nginx, cette commande doit répertorier ce pod avec son statut. Voir la sortie suivante :
Étape 6 : Analysez les événements Kubernetes
Maintenant, analysons les événements dans Kubernetes afin de pouvoir définir la tolérance sur les pods en conséquence. Nous utilisons la commande kubectl suivante pour obtenir la liste des événements dans Kubernetes :
> kubectl obtenir des événements -n l'extrémité avantCela répertorie tous les événements associés à la valeur frontale ainsi que leurs propriétés telles que le type, la raison, l'objet et le message. Voir la liste donnée dans la sortie suivante :
Comme vous pouvez le voir dans la sortie précédente, le pod nginx est planifié avec la tolérance spécifique. La propriété 'message' affiche la liste des actions qui sont effectuées tout au long du processus.
Étape 7 : Vérifier l'état des pods
La dernière étape consiste à vérifier à nouveau le statut du pod que nous avons créé précédemment pour nous assurer qu'il est planifié avec succès sur un nœud spécifique et correct. Pour ce faire, nous utilisons la commande kubectl suivante :
> kubectl obtenir des pods -n l'extrémité avant 
Comme on peut le voir dans la sortie précédente, le pod est désormais autorisé à s'exécuter sur le nœud entaché puisque la tolérance lui est associée.
Conclusion
Dans ce guide, nous avons exploré les souillures et la tolérance. Nous avons appris le fonctionnement de base des souillures et de la tolérance. Ensuite, nous avons implémenté la tolérance sur un pod. À l'aide d'un exemple simple, nous avons appris à définir la tolérance sur un nœud dans Kubernetes.