Étape 10 : Déploiement et contrôles du cluster

En bref
  • Exécution du playbook xkub_30_cluster.yml depuis WSL, puis relance pour vérifier l’idempotence.
  • Contrôles sur le premier control plane : containerd et crictl, kubeadm-config.yaml, cilium-values.yaml, static pods et kubeconfig admin.
  • Premières commandes kubectl : nodes Ready, labels, taints DMZ, pods et focus sur CoreDNS (réplicas, podAntiAffinity, tolérances).
  • Santé d’etcd (leader, quorum RAFT), de Cilium (status, connectivity test) et de la VIP kube-vip de l’API.

Introduction

Le moment est venu de passer à l’action.

Les articles précédents ont servi à décrire le contenu du playbook Ansible xkub_30_cluster.yml en détaillant chaque rôle appelé :

  • xkub_kube_vip : déploiement de la solution responsable de l’accès à l’API K8S et de la haute disponibilité de cette dernière, répartie entre les trois instances du contrôleur de cluster.
  • xkub_kubeadm_init : initialisation du premier contrôleur de cluster avec le déploiement des composants de base à travers les pods statiques et l’utilisation de kubeadm.
  • xkub_kubeadm_join : ajout de tous les nœuds, avec la distinction entre les contrôleurs de cluster et les nœuds de travail.
  • xkub_cilium : déploiement via Helm du CNI (Container Network Interface) Cilium.

À chaque description des actions, on en a profité pour travailler un peu la théorie et expliquer certains grands principes rattachés à chacune de ces étapes.

Il est maintenant temps de lancer ce fameux playbook afin de laisser faire la magie et obtenir en sortie un cluster Kubernetes prêt à être exploité.

Lancement du playbook

Pour cela, rien de plus simple, puisqu’on s’appuie sur la couche Ansible déployée dans mon instance WSL à partir de mon poste W11. N’hésitez pas à revoir la logique pour être à l’aise avec les commandes et l’arborescence ansible utilisées.

ansible-playbook playbooks/xkub_30_cluster.yml

Le playbook va être déroulé, appelant rôle après rôle pour les appliquer aux bonnes cibles issues de l’inventaire.

À ce stade, je rappelle que les load balancers HAproxy ont déjà été déployé, c’est donc l’ensemble des nodes K8S qui vont être touchées avec un focus sur le premier control plane, prdk8sgru501 puisque c’est lui qui va servir à établir la configuration de départ du cluster. L’ensemble des autres nodes ne feront que rejoindre ce dernier ensuite pour composer l’ensemble du cluster.

On lance donc la commande.

Lancement du playbook xkub_30_cluster.yml depuis WSL : play kube-vip sur les trois control planes

Cliquez sur l'image pour l'agrandir.

On va pouvoir suivre l’ensemble des actions réalisées. Ces dernières vont prendre plusieurs minutes à s’exécuter, mais, en moins d’un quart d’heure, on doit avoir le compte rendu final affiché par Ansible sans avoir rencontré d’erreur.

Tâches du rôle xkub_kubeadm_init : fichier de configuration kubeadm, kubeadm init et copie du kubeconfig admin

Cliquez sur l'image pour l'agrandir.

Retour de kube-vip sur admin.conf puis début du play kubeadm join

Cliquez sur l'image pour l'agrandir.

Tâches du rôle xkub_kubeadm_join : join des control planes CP2/CP3 puis des workers

Cliquez sur l'image pour l'agrandir.

Tâches du rôle xkub_cilium : installation de Helm, du plugin helm-diff, de cilium-cli et du chart Cilium

Cliquez sur l'image pour l'agrandir.

PLAY RECAP de la première exécution du playbook xkub_30_cluster.yml sans aucune erreur

Cliquez sur l'image pour l'agrandir.

Relance du playbook

Par contre, il ne faut pas se contenter d’une seule exécution. Comme dit à de nombreuses reprises, un code ansible correct est un code idempotent, c’est-à-dire qu’il peut être rejoué sans risque une fois les modifications appliquées.

C’est donc ce que nous allons faire.

Seconde exécution du playbook xkub_30_cluster.yml : les tâches kube-vip ressortent en ok

Cliquez sur l'image pour l'agrandir.

Cette fois-ci, le déroulement devrait se faire plus vite et le résumé final ne contenir aucun changement. Ce n’est malheureusement pas mon cas, puisque j’ai tout de même une modification affichée, apparemment liée à Cilium…c’est une correction que je devrais faire, mais on va dire qu’à ce stade, ce n’est pas trop grave et que, dans tous les cas, le playbook peut être relancé sans erreur.

PLAY RECAP de la seconde exécution : un seul changement restant, sur le chart Helm Cilium

Cliquez sur l'image pour l'agrandir.

Contrôles sur le premier control plane

Normalement le cluster est opérationnel, mais il va falloir tout de même vérifier l’ensemble. C’est l’occasion aussi de parler de certains fondamentaux et d’initier ses premiers contacts avec ce nouveau cluster K8S.

On va donc se focaliser dans un premier temps sur un ensemble de commandes qu’on va exécuter manuellement sur le premier control plane en s’y connectant en ssh (avec le même compte que celui utilisé par ansible)

Dans les faits, on ne fait que très rarement cet accès direct à l’un des control planes. On réserve ces opérations uniquement sur la maintenance ou l’incident, ou encore, comme ici, pour de premiers tests avant la mise en production du cluster.

Par la suite on fera toujours des accès distants à l’API via des points de connexion sécurisés, comme un bastion ou des environnements de travail spécifiques réservés à des accès administratifs au cluster. Noter déjà bien que les accès API sont très sensibles et que c’est très important de définir les méthodes d’accès en entreprise. Il sera nécessaire de capitaliser ensuite sur les fonctions de RBAC de K8S pour donner les bons droits aux bonnes personnes : on aura l’occasion d’en reparler, mais vous pouvez déjà consulter mon article dédié au sujet.

Nous voilà donc sur le shell du premier control plane.

Le runtime containerd

Première chose, on va vérifier si containerd est bien démarré et opérationnel. Il faisait partie des prérequis à K8S puisque, pour rappel, K8S ne propose pas de moteur d’exécution de conteneur, mais il s’interface avec un runtime compatible CRI (Container Runtime Interface) dont la combinaison containerd/crun font partie. N’hésitez pas également à consulter la partie dédiée au sujet dans la présentation de l’architecture retenue pour ce cookbook.

Pour çà, un bête sudo systemctl status containerd suffit à vérifier que le service est actif. Idéalement on pourrait le faire sur chaque node.

Commande systemctl status containerd : le service containerd est actif sur prdk8sgru501

Cliquez sur l'image pour l'agrandir.

On va aller un peu plus loin avec la commande crictl. Souvenez-vous, on l’a intégré dans le rôle xkub_k8s_prereqs lors de l’installation de Containerd. Un peu à l’image de la classique commande docker, on va pouvoir interroger le runtime sans passer par des commandes kubectl.

sudo /usr/local/bin/crictl info

Cette instruction nous donne les infos d’état et la configuration détaillée du moteur. Tout semble correct à ce niveau.

Sortie de crictl info : configuration CNI loopback et cilium du runtime

Cliquez sur l'image pour l'agrandir.

On enchaine avec sudo /usr/local/bin/crictl ps -a

sudo /usr/local/bin/crictl ps -a

On obtient alors l’ensemble des conteneurs présent sur le node. On y retrouve déjà nos images associées aux couches de bases de Kubernetes, comme l’API Serveur, ETCD et le scheduler.

Sortie de crictl ps -a : conteneurs etcd, kube-apiserver, kube-scheduler, kube-vip et conteneurs init Cilium en état Exited

Cliquez sur l'image pour l'agrandir.

Vous remarquez aussi des conteneurs arrêté, lié principalement à Cilium. C’est normal à ce stade, car, lors du déploiement de Cilium et d’autres composants, il est possible que des conteneurs temporaires soient déployés, le temps d’effectuer des tests ou des configurations spécifiques. On parle souvent de conteneur « init » qui s’occupe de préparer le terrain pour la suite et qui, une fois sa tâche accomplie, se termine simplement.

Les fichiers de configuration

On peut continuer notre exploration. Cette fois-ci, nous allons effectuer un petit contrôle de notre configuration Kubernetes poussée par Ansible.

Rappelez-vous que cette dernière a été déployée dans un fichier yaml issu d’un template jinja et placé dans /etc/kubernetes/

On peut donc consulter son contenu

sudo cat /etc/kubernetes/kubeadm-config.yaml
Contenu du fichier /etc/kubernetes/kubeadm-config.yaml rendu par Ansible : version 1.36.5, podSubnet 10.11.0.0/16, serviceSubnet 10.12.0.0/16 et certSANs

Cliquez sur l'image pour l'agrandir.

Effectivement, notre version désirée de Kubernetes se trouve bel et bien ici, comme indiqué dans le fichier « versions.yml » situé dans le dossier « group_vars\clu_k8s_xkub » de l’arborescence « inventory » sur mon poste de travail. Il est possible que la version ait changé depuis la rédaction initiale du premier article, en raison du délai que je peux avoir entre les différentes écritures des étapes. Ne vous focalisez pas là-dessus.

Éléments importants qu’on retrouve aussi, les subnet associés à nos pod (10.11.0.0/16) et nos services (10.12.0.0/16) ainsi que tout nom qui pourrait être associé derrière le certificat utilisé par l’API.

C’est bien ce fichier poussé par ansible qui ensuite a été lue par kubeadm lors de l’exécution du rôle xkub_kubeadm_init pour définir la configuration de notre cluster.

Faisons de même avec la configuration de cilium qui elle, devrait apparaitre également dans /etc/kubernetes/ mais via le fichier cilium-values.yaml.

Contenu du fichier /etc/kubernetes/cilium-values.yaml : kubeProxyReplacement, k8sServiceHost 192.168.10.121 et pool 10.11.0.0/16

Cliquez sur l'image pour l'agrandir.

Ici aussi, Ansible a fait son travail et la configuration est conforme à nos attentes, avec la référence à l’IP utilisé comme VIP pour l’accès à l’API k8s ainsi que le pool d’adresse de nos pods (10.11.0.0/16)

Les static pods

Une autre observation intéressante à faire et d’aller faire un tour dans le dossier /etc/kubernetes/manifests, puisque c’est la qu’on va retrouver nos fameux static pods, soit les pods surveillés par l’agent kubelet disponible sur chaque node.

Contenu du dossier /etc/kubernetes/manifests : etcd, kube-apiserver, kube-controller-manager, kube-scheduler et kube-vip

Cliquez sur l'image pour l'agrandir.

On y retrouve tous les fichiers yamls propres aux fondamentaux d’un cluster Kubernetes

  • etcd : la base clef valeur répliquée entre chaque control plane et qui contient l’intégralité de la configuration du cluster
  • apiserver : le point d’entrée pour interagir avec le cluster
  • controller-manager : le composant k8s en charge de maintenir l’état réel du cluster conforme à l’état désirée
  • scheduler : le composant k8s en charge de choisir sur quel nœud un nouveau pod doit être exécuté.
  • kube-vip : le seul élément qui ne fait pas partir des briques par défaut, mais qui correspond à notre choix de gérer la vip de l’API avec cette solution (associé au rôle xkub_kube_vip)

Il faut bien comprendre que, lorsque kubeadm a été appelé, il a exploité le fichier de configuration passé en argument pour générer ces yamls (hors kube-vip), afin qu’ils soient ensuite pris en charge par le kubelet, qui a pu exécuter les composants. Ces fichiers sont critiques et il est possible de les éditer directement pour venir modifier la configuration du cluster. D’ailleurs, à chaque modification, les composants associés sont automatiquement relancés par le kubelet.

Premières commandes kubectl

Enfin, passons à l’appel de nos premières commandes kubectl, soit la CLI officielle de Kubernetes.

Celle-ci va exploiter le fichier de configuration config présent dans le profil de notre utilisateur au niveau du répertoire caché .kube/

cat .kube/config
Contenu du fichier .kube/config du compte ansible-windows, certificats et clé privée masqués

Cliquez sur l'image pour l'agrandir.

Ce fichier contient les éléments de connexion au cluster à commencer par l’URL de l’API (https://xkub.coolcorp.priv:6443) ainsi que le certificat associé et la clef privée de l’utilisateur pour accéder à la configuration K8S à travers l’API.

Cette configuration a elle aussi été générée lors du déroulé du rôle xkub_kubeadm_init et de l’appel à kubeadm. Elle couvre l’accès au cluster en mode cluster admin, soit le plus haut niveau d’autorisation qui permet de faire tout ce que l’on souhaite sur le cluster. Son contenu est donc extrêmement critique et doit être manipulé avec précaution. Nous nous trouvons actuellement dans une étape post-déploiement où nous surveillons attentivement les opérations. Cependant, dans un environnement de production, il est préférable d’éviter d’exploiter directement ce fichier sur le contrôleur qui a servi à lancer le cluster, sauf en cas d’urgence.

Nodes, labels et taints

Néanmoins c’est grâce à cela qu’on va pouvoir vérifier l’état des nodes avec la commande « kubectl get node »

kubectl get node
Sortie de kubectl get node : les sept nodes du cluster en état Ready, control-plane, worker-lan et worker-dmz

Cliquez sur l'image pour l'agrandir.

Très bonne nouvelle. Tous les serveurs se trouvent en mode « Ready ». À ce stade, nous pouvons déjà identifier les control plane des workers, et pour ces derniers, nous avons une distinction dans leur rôle en fonction de leur emplacement sur le réseau. Preuve que les labels ont été appliqués.

On peut d’ailleurs les vérifier plus en profondeur avec la commande « kubectl get nodes --show-labels »

kubectl get nodes --show-labels
Sortie de kubectl get nodes --show-labels : labels network=lan et network=dmz posés sur les workers

Cliquez sur l'image pour l'agrandir.

Tout est là, et c’est grâce au module ansible k8s utilisé dans le rôle « xkub_kubeadm_join » que ces derniers ont pu être placés.

D’ailleurs, rappelez-vous, on ne souhaitait pas que des labels, mais aussi des taint. N’hésitez pas à revoir la partie qui en parle pour bien comprendre la différence entre les deux et pourquoi on les utilise.

On les vérifie aussi, mais avec la commande kubectl describe nodes | grep -E "Name:|Taints:"

kubectl describe nodes | grep -E "Name:|Taints:"
Taints des nodes : control-plane:NoSchedule sur les control planes et network=dmz:NoSchedule sur les workers DMZ

Cliquez sur l'image pour l'agrandir.

On a bien nos taints sur les nodes en DMZ qui vont nous être bien utile pour éviter que des composants se retrouvent en DMZ sans qu’on en ait explicitement fait la demande.

Ressources et pods

Continuons avec la commande kubectl get all -A.

kubectl get all -A
Sortie de kubectl get all -A : liste des pods du namespace kube-system

Cliquez sur l'image pour l'agrandir.

Suite de kubectl get all -A : services, daemonsets, deployments et replicasets

Cliquez sur l'image pour l'agrandir.

Le retour est conséquent, puisqu’on demande à l’API de nous lister toutes les ressources (all) pour tous les namespaces (-A).

Attention néanmoins, car toutes les ressources sont trompeuses, l’API renvoyant uniquement les types d'objets principaux: pods, deployment et services. Néanmoins ça fait déjà du monde et surtout dans le namespace kube-system, qui je vous le rappelle est le namespace par défaut dans lequel on va retrouver tous les composants critiques du cluster. On a la capacité d’y accéder parce que, comme dit plus haut, on utilise l’accès admin pour l’appel à l’API.

Pour l’instant bonnes nouvelles, tous nos pods sont dans l’état désiré. On peut d’ailleurs faire un focus dessus avec la commande kubectl get pod -A

kubectl get pod -A
Sortie de kubectl get pod -A : colonnes READY, STATUS et RESTARTS de tous les pods du cluster

Cliquez sur l'image pour l'agrandir.

La colonne READY est particulièrement intéressante, puisqu’elle indique pour chaque pod combien de conteneurs sont up sur ceux qui sont attendus. L’occasion de faire le point sur la notion de pod. Je ne vais pas m’étaler, tout est expliqué dans cette définition, mais un pod peut référencer plusieurs conteneurs. Par exemple, dans cette capture, le pod « hubble-ui-865d8bd5cf-lq7sj » contient deux conteneurs dans le pods et les deux sont lancés.

En l’état, c’est excellent : tous les conteneurs de tous les pods sont démarrés et on n’a noté aucun redémarrage (ce qui pourrait laisser croire qu’il y a un problème).

Focus sur les composants clefs

CoreDNS

Faisons un focus sur quelques composants clefs dont on n’a pas encore parlé : les DNS

Comme déjà expliqué lors d’articles précédents, notamment lorsqu’on a présenté le rôle xkub_cilium et parlé du réseau, Kubernetes vient avec une résolution interne sous gestion de core-dns .

On retrouve donc au moins deux instances de core dns sur le cluster

kubectl get pod -n kube-system -o wide | grep dns
Les deux pods CoreDNS du cluster, tous deux exécutés sur le worker prdk8smin502

Cliquez sur l'image pour l'agrandir.

L’option -o wide nous permet d’obtenir le nom des nodes sur lesquels actuellement ces pods sont exécutés, et il ne s’agit pas des control plane. En effet, core-dns est autorisé à s’exécuter sur les worker…mais grâce à nos taint dont on a parlé précédemment, l’orchestrateur ne pourra utiliser que des nodes du lan.

Toutefois, il y a une subtilité : la configuration de CoreDNS n’est pas incluse dans un manifeste au sein des pods statiques, mais elle est directement écrite dans Etcd lors de l’initialisation du cluster.

On peut avoir le détail du deployment en appelant directement le contenu de la conf associé via la commande

kubectl get deployment -n kube-system -l k8s-app=kube-dns -o yaml

Cette commande permet de recouper la configuration du deployment associé au label k8s-app=kube-dns dans le namespace kube-system avec une sortie (-o) en yaml.

L’API consulte la base etcd et nous donne les caractéristiques de l’objet demandé.

Deployment CoreDNS en yaml : replicas 2 et règle podAntiAffinity preferredDuringSchedulingIgnoredDuringExecution

Cliquez sur l'image pour l'agrandir.

Sans rentrer dans le détail à ce stade, ce type de commande est très pratique pour obtenir la configuration de n’importe quel objet Kubernetes, voire même à reconstruire les yamls pour éventuellement les modifier et redéployer le composant ensuite.

Par exemple, ici, on voit bien qu’il a été demandé un réplica 2…on pourrait le passer à trois si on estime en avoir besoin. On voit bien aussi qu’aucune toleration n’est associée à nos taint sur les nodes en DMZ, donc aucun risque que les pods DNScore se retrouvent là-bas. Autres choses intéressantes, on observe une configuration podAntiAffinity, qui permet ici de donner une règle visant à éviter que les pods DNS se retrouvent sur le même node pour favoriser la résilience en cas de perte d’un serveur.

Or si on regarde la sortie de la commande précédente (kubectl get pod -n kube-system -o wide | grep dns), ben les deux pods sont sur prdk8smin502.coolcorp.priv : pourquoi ? Parce que la règle est en mode « best effort »…ce n’est pas une obligation, mais c’est conseillé.

D’ailleurs, essayons de stopper un des pod…chose à éviter en production, bien sûr… mais, comme il y en a deux d’actifs, en arrêter un ne devrait pas avoir d’impact

On peut faire ça avec la commande : kubectl delete pod coredns-589f44dc88-dsmpd -n kube-system (ici j’ai pris le nom du pod tel qu’il apparait dans le listing, mais ce nom est dynamique et change à chaque instanciation)

kubectl delete pod coredns-589f44dc88-dsmpd -n kube-system
Suppression du pod coredns-589f44dc88-dsmpd avec kubectl delete pod

Cliquez sur l'image pour l'agrandir.

Si je cherche à nouveau à observer les pod dns

kubectl get pod -n kube-system -o wide | grep dns
Nouveau pod CoreDNS recréé par le deployment depuis 53 secondes sur le control plane prdk8sgru502

Cliquez sur l'image pour l'agrandir.

J’ai toujours deux pods, mais l’un avec une apparition depuis seulement quelques secondes. C’est normal, j’ai stoppé le pod, mais pas le deployment qui le contrôle et qui dit « j’en veux toujours 2 » via l’option replica. Le composant controller du cluster a donc fait son travail et a immédiatement relancé un pod….L’orchestrateur lui a tenu compte de la règle de podAntiAffinity et, cette fois-ci a pu lancer ce nouveau pod sur prdk8sgru502.coolcorp.priv, soit un autre node que prdk8smin502.coolcorp.priv où se trouve déjà le premier pod.

Pour quelle raison a-t-il choisi un contrôleur comme serveur ? Tout simplement parce que, contrairement à notre configuration sur les nœuds en DMZ, la configuration du déploiement de DNS core tolère effectivement une exécution sur un contrôleur.

Tolérances du deployment CoreDNS : CriticalAddonsOnly et node-role.kubernetes.io/control-plane NoSchedule

Cliquez sur l'image pour l'agrandir.

Si vous avez suivi jusque-là ce cookbook, alors vous devriez rattacher tout ce qu’on a vu jusqu’à présent et commencer à comprendre comment s’articule le fonctionnement de base de K8S même sans avoir été dans le détail.

La base etcd

Poursuivons avec un autre composant clef : la base etcd. C’est souvent elle l’une des causes d’incident sous Kubernetes. C’est elle qui impose d’avoir au moins trois control plane pour assurer la haute disponibilité de l’ensemble. Elle implique aussi des contraintes réseau importantes entre les control plane, puisque ces derniers doivent répliquer la base ; pour que cette réplication fonctionne bien, il faut de très faible latence… C’est pourquoi, même si cela peut sembler une bonne idée, éclater ses contrôleurs sur des hébergements variés rattachés entre eux par des liaisons réseau autres que locales peut créer des problèmes.

Via la commande « kubectl get pod -n kube-system -o wide | grep etcd » on peut voir qu’on a bien une instance (un pod) etcd par control plane

kubectl get pod -n kube-system -o wide | grep etcd
Un pod etcd par control plane : prdk8sgru501, prdk8sgru502 et prdk8sgru503

Cliquez sur l'image pour l'agrandir.

On peut aller plus loin et contrôler spécifiquement l’état de ces instances etcd et de la réplication de la base.

Pour ça, en utilisant l’IA pour gagner du temps, on va créer une fonction « etcdctl » pour permettre d’interagir avec etcd en passant des commandes dans les pods associés (via crictl). Il faut savoir que etcdctl existe en tant que binaire installable sur le serveur, mais on va pouvoir s’en passer grâce à cette astuce (merci l’IA)

EID=$(sudo /usr/local/bin/crictl ps --name etcd --state Running -q | head -1)
etcdctl() {
  sudo /usr/local/bin/crictl exec "$EID" etcdctl \
    --endpoints=https://127.0.0.1:2379 \
    --cacert=/etc/kubernetes/pki/etcd/ca.crt \
    --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt \
    --key=/etc/kubernetes/pki/etcd/healthcheck-client.key \
    "$@"
}
Déclaration de la fonction shell etcdctl qui exécute etcdctl dans le conteneur etcd via crictl exec

Cliquez sur l'image pour l'agrandir.

Si etcdctl n'existe pas sur le serveur (voir ma remarque plus haut), elle est bien présente dans le conteneur qui fait tourner etcd. On va rentrer dans le contexte de ce dernier, puis passer en argument de la commande etcdctl qui s’y trouve : le endpoint de connexion (127.0.0.1:2379 (normal, c’est le conteneur, etcd lui-même)) et les éléments d’authentification qui ne sont autres que la clef et le certificat généré pendant le déploiement de etcd.

On peut ainsi maintenant lister les membres

etcdctl member list -w table
etcdctl member list : les trois membres etcd démarrés avec leurs adresses peer 2380 et client 2379

Cliquez sur l'image pour l'agrandir.

On peut aussi voir le statut global du cluster

etcdctl endpoint health --cluster -w table
etcdctl endpoint health --cluster : les trois endpoints etcd sont sains

Cliquez sur l'image pour l'agrandir.

etcdctl endpoint status --cluster -w table
etcdctl endpoint status --cluster : prdk8sgru501 (192.168.10.161) est le leader etcd

Cliquez sur l'image pour l'agrandir.

Leader et quorum

Et chose intéressante sur cette sortie, on peut voir que, parmi les serveurs participant au cluster, mais au sens etcd du terme, un seul est actuellement « leader » à savoir prdk8sgru501. Les autres ne font que répliquer le contenu, mais, au moment de cette commande, c’est la version de la base présente sur prdk8sgru501 qui sert de référence et manipulée en écriture. Si celui-ci venait à tomber, et donc à voir son pod arrêté, alors les survivants entreraient dans un état d’élection pour savoir qui de l’un ou de l’autre prendra le relais…parce qu’ils sont encore en nombre suffisant pour « élir » un nouveau leader… Vous comprenez maintenant pourquoi il faut au moins trois nœuds… c’est le principe du protocole RAFT rattaché à etcd qui demande à avoir toujours un quorum suffisant de nœuds pour avoir une élection. Avec seulement deux nodes, si vous en perdez un, le seul restant ne peut pas décider de lui-même de prendre la main et a besoin de la voix d’un autre pour s’accorder sur les suites…et c’est normal…Imaginez que vous ayez deux nœuds, mais que le leader se retrouve isolé sur le plan du réseau. Chacun continue de tourner, mais ne peut plus discuter avec son voisin. Comment le nœud survivant peut-il décider qu'il peut maintenant enregistrer et suivre les modifications ? Peut-être que c’est lui qui est isolé ? : c’est un cas de splitbrain. Maintenant, si ce dernier peut communiquer avec un troisième qui lui confirme que lui non plus ne voit plus le leader, alors ils peuvent se mettre d’accord pour que l’un des deux reprenne la charge.

C’est très simplifié, mais cela vous montre que choisir le nombre de ces control plane et leur emplacement dans une architecture n’est pas anodin. Voilà aussi pourquoi les clusters managés offerts par certains opérateurs cloud sont intéressants… car, dans ce cas, ce n’est plus votre problème, les control plane étant à la charge du provider.

Cilium

Poursuivons maintenant avec Cilium, notre CNI.

Comme vous avez sans doute pu déjà le constater, on a vu pas mal de pod cilium dans le namespace kube-system. Le fait que les nodes apparaissent en « Ready » et que les pod DNS core soient actifs sont déjà un de bons indices pour se dire que le CNI est monté correctement. Le réseau interne fonctionne, car, sans cela, ces éléments n’apparaitraient pas ainsi.

Mais assurons-nous tout de même de la bonne santé de cilium. Pour cela, rappelez-vous que, dans le rôle xkub_cilium, on a déployé la CLI.

Faisons appel à cette dernière :

sudo /usr/local/bin/cilium status --wait --kubeconfig /etc/kubernetes/admin.conf

Ici, on ne peut pas s’appuyer sur le fichier de config utiliser par kubectl (vu qu’on doit être en sudo), mais on précise directement le fichier admin.conf présent dans /etc/kubernetes/ qui n’est autre que la version original du fichier config présent dans le profil de notre compte ansible. Rappelez-vous que dans le rôle xkub_kubeadm_init c’est la dernière étape dans les taches, copiez admin.conf en tant que config dans le dossier .kube de l’utilisateur local.

La sortie de la commande nous montre que tout est au vert concernant cilium.

Sortie de cilium status : Cilium, Operator, Envoy DaemonSet et Hubble Relay en OK, chart Helm 1.20.4

Cliquez sur l'image pour l'agrandir.

Pour ceux qui veulent aller plus loin, il y a aussi cette commande

sudo /usr/local/bin/cilium connectivity test --kubeconfig /etc/kubernetes/admin.conf

Celle-ci va déclencher toute une série de tests qui peuvent durer assez longtemps (plusieurs heures) dans lequel des pods vont être exécutés pour tester différents niveaux de connectivité et de fonctionnalités propre à Cilium.

Démarrage de cilium connectivity test : déploiement des namespaces et pods de test

Cliquez sur l'image pour l'agrandir.

Déroulement de cilium connectivity test : scénarios pod-to-host, host-to-pod et pod-to-cidr

Cliquez sur l'image pour l'agrandir.

C’est le dernier test pour vérifier que tout fonctionne correctement, y compris les ports de pare-feu firewalld entre les nœuds. Mais attention, il n’est pas rare qu’en fin d’exécution des tests échouent et ça ne veut pas forcément dire qu’il y a un souci. Certains tests ne sont juste pas appropriés à la configuration en place. Il faut donc être prudent dans l’interprétation des tests.

Tests cilium connectivity en échec sur la résolution de one.one.one.one, à interpréter avec prudence

Cliquez sur l'image pour l'agrandir.

Accès à l'API et kube-vip

Enfin, dernière petite chose : tester l’accès à l’API depuis l’extérieur, et donc également kube-vip.

Déjà, validons que les pods kube-vip sont en place.

kubectl get pod -n kube-system  -o wide| grep vip
Un pod kube-vip par control plane, en état Running

Cliquez sur l'image pour l'agrandir.

Ensuite, depuis mon poste de travail, de simples commandes curl dans WSL suffisent à nous rassurer sur ce point, puisqu’en utilisant l’IP de la VIP j’arrive bien à solliciter l’API

curl -sk https://192.168.10.121:6443/livez ; echo
curl -sk https://xkub.coolcorp.priv:6443/livez ; echo
Appels curl sur /livez de l'API via l'IP de la VIP 192.168.10.121 et via xkub.coolcorp.priv : réponse ok

Cliquez sur l'image pour l'agrandir.

À ce stade, je ne peux rien lui demander, puisque, sur mon poste, je n’ai pas de fichier de config, mais c’est déjà suffisant pour valider l’exposition de cette dernière.

D’ailleurs, si on est curieux, en faisant un simple ping vers la VIP puis en utilisant la commande arp -a pour lister l’adresse mac associer à l’IP, on peut identifier facilement que c’est pour l’instant le serveur prdk8sgru501 qui porte cette dernière.

Ping de la VIP 192.168.10.121 puis arp -a : la VIP partage l'adresse MAC de prdk8sgru501 (192.168.10.161)

Cliquez sur l'image pour l'agrandir.

Adresse MAC de la VM prdk8sgru501 dans Xen Orchestra, identique à celle portée par la VIP

Cliquez sur l'image pour l'agrandir.

Conclusion

Nous voilà arrivés au bout de cette étape intermédiaire. A ce stade, notre cluster est en place et apte à être utilisé pour la suite. Ces composants de bases sont en place et le réseau est actif.

Malgré l’usage de Ansible pour automatiser l’ensemble et le tout assisté par l’IA, il convient de comprendre ce qui a été fait et d’avoir en tête les mécanismes sous-jacents qui ont été utilisés pour arriver à ce résultat.

On va désormais pouvoir enchainer sur l’ajout de composant tiers, pour offrir davantage de services à nos applications conteneurisées. Pour cela il va falloir attendre la suite des articles.