Pods statiques d'une journée complète de cours CKA, planification manuelle, étiquettes et sélecteurs dans Kubernetes

Tâche : Planifier un pod manuellement sans le planificateur

Dans cette tâche, nous explorerons comment contourner le planificateur Kubernetes en attribuant directement un pod à un nœud spécifique dans un cluster. Cela peut être une approche utile pour des scénarios spécifiques dans lesquels vous avez besoin d'un pod pour s'exécuter sur un nœud particulier sans passer par le processus de planification habituel.

Conditions préalables

Nous supposons que vous disposez d'un cluster Kubernetes en cours d'exécution, créé avec une configuration KIND (Kubernetes in Docker) similaire à celle décrite dans les articles précédents. Ici, nous avons créé un cluster nommé kind-cka-cluster :

kind create cluster --name kind-cka-cluster --config config.yml

Puisque nous avons déjà abordé la création de clusters avec KIND dans des articles précédents, nous n'entrerons pas dans ces détails à nouveau.

Étape 1 : Vérifiez les nœuds du cluster

Pour voir les nœuds disponibles dans ce nouveau cluster, exécutez :

kubectl get nodes

Vous devriez voir un résultat similaire à celui-ci :

NAME                           STATUS   ROLES           AGE   VERSION
kind-cka-cluster-control-plane Ready    control-plane   7m   v1.31.0

Pour cette tâche, nous planifierons notre pod sur kind-cka-cluster-control-plane.

Étape 2 : Définir le manifeste du pod (node.yml)

Maintenant, créons un manifeste de pod au format YAML. En utilisant le champ nodeName dans notre configuration de pod, nous pouvons spécifier le nœud exact du pod, en contournant entièrement le planificateur Kubernetes.

node.yml :

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx
  nodeName: kind-cka-cluster-control-plane

Dans ce manifeste :

• Nous définissons nodeName sur kind-cka-cluster-control-plane, ce qui signifie que le planificateur ignorera l'attribution d'un nœud et que le Kubelet sur ce nœud spécifique gérera le placement à la place.

Cette approche est une méthode directe de sélection de nœuds, remplaçant d'autres méthodes comme nodeSelector ou les règles d'affinité.

D'après la documentation Kubernetes :

"nodeName est une forme plus directe de sélection de nœud que l'affinité ou le nodeSelector. nodeName est un champ dans la spécification du Pod. Si le champ nodeName n'est pas vide, le planificateur ignore le Pod et le kubelet sur le nœud nommé essaie de le placer le Pod sur ce nœud. L'utilisation de nodeName annule l'utilisation de nodeSelector ou des règles d'affinité et d'anti-affinité."

Pour plus de détails, reportez-vous à la documentation Kubernetes sur l'affectation des nœuds.

Étape 3 : Appliquer le manifeste du pod

Une fois notre manifeste prêt, appliquez-le au cluster :

kubectl apply -f node.yml

Cette commande crée le pod nginx et l'assigne directement au nœud kind-cka-cluster-control-plane.

Étape 4 : Vérifier l'emplacement des pods

Enfin, vérifiez que le pod s'exécute sur le nœud spécifié :

kubectl get pods -o wide

La sortie devrait confirmer que le pod nginx s'exécute effectivement sur kind-cka-cluster-control-plane :

kind create cluster --name kind-cka-cluster --config config.yml

Cela vérifie qu'en définissant le champ nodeName, nous avons réussi à contourner le planificateur Kubernetes et à planifier directement notre pod sur le nœud du plan de contrôle.

Tâche : Connectez-vous au nœud du plan de contrôle, accédez au répertoire des manifestes de pod statiques par défaut et essayez de redémarrer les composants du plan de contrôle.

Pour accéder au nœud du plan de contrôle de notre cluster nouvellement créé, utilisez la commande suivante :

kubectl get nodes

Accédez au répertoire contenant les manifestes du pod statique :

NAME                           STATUS   ROLES           AGE   VERSION
kind-cka-cluster-control-plane Ready    control-plane   7m   v1.31.0

Vérifiez les manifestes actuels :

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx
  nodeName: kind-cka-cluster-control-plane

Pour redémarrer le kube-controller-manager, déplacez temporairement son fichier manifeste :

kubectl apply -f node.yml

Après avoir confirmé le redémarrage, remettez le fichier manifeste à son emplacement d'origine :

kubectl get pods -o wide

Grâce à ces étapes, nous avons démontré avec succès comment accéder au plan de contrôle et manipuler les manifestes du pod statique pour gérer le cycle de vie des composants du plan de contrôle.

Confirmation du redémarrage de kube-controller-manager

Après avoir temporairement déplacé le fichier manifeste kube-controller-manager.yaml vers /tmp, nous pouvons vérifier que kube-controller-manager a redémarré. Comme mentionné dans les articles précédents, j'utilise k9s, ce qui montre clairement le redémarrage, mais pour les lecteurs sans k9, essayez la commande suivante

Inspecter les événements :
Pour recueillir plus d'informations, utilisez :

NAME    READY   STATUS    RESTARTS   AGE   IP           NODE                             NOMINATED NODE   READINESS GATES
nginx   1/1     Running   0          28s   10.244.0.5   kind-cka-cluster-control-plane   <none>           <none>

Recherchez les événements à la fin de la sortie. Un redémarrage réussi affichera des événements similaires à :

docker exec -it kind-cka-cluster-control-plane bash

La présence des événements « Killing », « Created » et « Started » indique que le kube-controller-manager a été arrêté puis redémarré avec succès.

Nettoyage

Une fois que vous avez terminé vos tâches et confirmé le comportement de vos pods, il est important de nettoyer toutes les ressources qui ne sont plus nécessaires. Cela permet de maintenir un environnement ordonné et de libérer des ressources dans votre cluster.

Liste des pods :
Tout d'abord, vous pouvez vérifier les pods actuellement exécutés dans votre cluster :

cd /etc/kubernetes/manifests

Vous pourriez voir un résultat comme celui-ci :

ls

Décrire le Pod :
Pour obtenir plus d'informations sur un pod spécifique, utilisez la commande décrire :

mv kube-controller-manager.yaml /tmp

Cela vous donnera des détails sur le pod, tels que son nom, son espace de noms, son nœud et d'autres configurations :

mv /tmp/kube-controller-manager.yaml /etc/kubernetes/manifests/

Supprimer le Pod :
Si vous constatez que le pod n'est plus nécessaire, vous pouvez le supprimer en toute sécurité avec la commande suivante :

   kubectl describe pod kube-controller-manager-kind-cka-cluster-control-plane -n kube-system

Vérifier la suppression :
Après avoir exécuté la commande delete, vous pouvez vérifier que le pod a été supprimé en répertoriant les pods :

   Events:
     Type    Reason   Age                    From     Message
     ----    ------   ----                   ----     -------
     Normal  Killing  4m12s (x2 over 8m32s)  kubelet  Stopping container kube-controller-manager
     Normal  Pulled   3m6s (x2 over 7m36s)   kubelet  Container image "registry.k8s.io/kube-controller-manager:v1.31.0" already present on machine
     Normal  Created  3m6s (x2 over 7m36s)   kubelet  Created container kube-controller-manager
     Normal  Started  3m6s (x2 over 7m36s)   kubelet  Started container kube-controller-manager

Assurez-vous que le pod nginx n'apparaît plus dans la liste.

En effectuant ces étapes de nettoyage, vous contribuez à garantir que votre cluster Kubernetes reste organisé et efficace.

Création de plusieurs pods avec des étiquettes spécifiques

Dans cette section, nous allons créer trois pods basés sur l'image nginx, chacun avec un nom unique et des étiquettes spécifiques indiquant différents environnements : env:test, env:dev et env:prod.

Étape 1 : Créer le script

Tout d'abord, nous allons créer un script qui contient les commandes pour générer les pods. Utilisez la commande suivante pour créer le fichier de script :

kind create cluster --name kind-cka-cluster --config config.yml

Ensuite, collez le code suivant dans le fichier :

kubectl get nodes

Étape 2 : Rendre le script exécutable

Après avoir enregistré le fichier, rendez le script exécutable avec la commande suivante :

NAME                           STATUS   ROLES           AGE   VERSION
kind-cka-cluster-control-plane Ready    control-plane   7m   v1.31.0

Étape 3 : Exécuter le script

Exécutez le script pour créer les pods :

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx
  nodeName: kind-cka-cluster-control-plane

Vous devriez voir un résultat indiquant la création des pods :

kubectl apply -f node.yml

Étape 4 : Vérifier les pods créés

Le script affichera alors le statut des pods créés :

kubectl get pods -o wide

À ce stade, vous pouvez filtrer les pods en fonction de leurs étiquettes. Par exemple, pour trouver le pod avec le label env=dev, utilisez la commande suivante :

NAME    READY   STATUS    RESTARTS   AGE   IP           NODE                             NOMINATED NODE   READINESS GATES
nginx   1/1     Running   0          28s   10.244.0.5   kind-cka-cluster-control-plane   <none>           <none>

Vous devriez voir un résultat confirmant que le pod est en cours d'exécution :

docker exec -it kind-cka-cluster-control-plane bash

Balises et mentions

• @piyushsachdeva
• Jour 13 : Tutoriel vidéo

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!