Clusters Ku­ber­netes : ex­pli­ca­tion et création

Un cluster Ku­ber­netes est un ensemble com­pre­nant au moins un plan de contrôle et plusieurs nœuds de travail sur lesquels sont exécutées des ap­pli­ca­tions con­te­neu­ri­sées. Le cluster gère au­to­ma­ti­que­ment le dé­ploie­ment, la mise à l’échelle et la tolérance aux pannes des con­te­neurs. Cette ar­chi­tec­ture permet d’exécuter les ap­pli­ca­tions de manière fiable et efficace dans des en­vi­ron­ne­ments dis­tri­bués.

Qu’est-ce qu’un cluster Ku­ber­netes ?

Un cluster est gé­né­ra­le­ment un ensemble d’or­di­na­teurs qui fonc­tion­nent comme une seule entité vue de l’extérieur. Dans Ku­ber­netes, ce sont plusieurs nœuds (nodes) qui sont regroupés en cluster plutôt que des or­di­na­teurs physiques. Ces nœuds peuvent être des machines physiques ou des machines vir­tuelles.

Il exécute les ap­pli­ca­tions con­te­neu­ri­sées et re­pré­sente le niveau le plus élevé de l’ar­chi­tec­ture Ku­ber­netes.

Quels sont les cas d’uti­li­sa­tion des clusters Ku­ber­netes ?

Les clusters sont un élément essentiel pour exploiter plei­ne­ment les avantages de Ku­ber­netes. Ils per­met­tent de déployer vos ap­pli­ca­tions sans dépendre de machines spé­ci­fiques. En pratique, ils assurent l’abs­trac­tion des con­te­neurs et leur exécution sur plusieurs or­di­na­teurs. De plus, ils ne sont pas liés à un système d’ex­ploi­ta­tion par­ti­cu­lier, ce qui les rend hautement portables.

Domaines d’ap­pli­ca­tion typiques :

• Dé­ploie­ment d’ap­pli­ca­tions complètes : ces ap­pli­ca­tions sont composées de plusieurs con­te­neurs et in­dé­pen­dantes du matériel sous-jacent. Cela permet de déployer ra­pi­de­ment des mises à jour ou de nouvelles fonc­tion­na­li­tés sans modifier de serveurs in­di­vi­duels, tout en ga­ran­tis­sant une exécution cohérente dans chaque en­vi­ron­ne­ment.
• Fonc­tion­ne­ment dans des ar­chi­tec­tures de mi­cro­ser­vices : les ap­pli­ca­tions peuvent com­mu­ni­quer entre elles et restent hautement évo­lu­tives. Les mi­cro­ser­vices peuvent être dé­ve­lop­pés, mis à jour et mis à l’échelle in­dé­pen­dam­ment les uns des autres, ce qui renforce l’agilité et la ré­si­lience de l’ensemble de l’ap­pli­ca­tion.
• Con­ti­nuous In­te­gra­tion (CI) et Con­ti­nuous Delivery (CD) : les processus d’in­té­gra­tion continue et de livraison continue au­to­ma­ti­sent le build, les tests et le dé­ploie­ment. Cela réduit les cycles de dé­ve­lop­pe­ment, limite les erreurs manuelles et permet de mettre plus ra­pi­de­ment en pro­duc­tion de nouvelles fonc­tion­na­li­tés ou cor­rec­tifs.

De quoi se compose un cluster Ku­ber­netes ?

Un cluster Ku­ber­netes se compose d’un plan de contrôle (control plane) et d’un ou plusieurs nœuds de travail (worker nodes).

Plan de contrôle

Le plan de contrôle constitue le cœur du cluster Ku­ber­netes. Il est chargé de la gestion et du pilotage global. Son rôle principal est de maintenir l’état souhaité du cluster, en dé­ter­mi­nant par exemple quelles ap­pli­ca­tions doivent s’exécuter, où et quand. Il se compose de plusieurs éléments clés :

• API Server : le serveur API est l’interface centrale du plan de contrôle. Il coordonne la com­mu­ni­ca­tion avec le cluster et définit l’état du système. L’in­te­rac­tion avec l’API Ku­ber­netes est possible via la ligne de commande (kubectl) ou via des in­ter­faces gra­phiques, comme la console Google Cloud.
• Scheduler : il répartit les pods sur les nœuds en fonction des res­sources dis­po­nibles. Il veille à ce que chaque pod Ku­ber­netes (groupe de con­te­neurs) soit cor­rec­te­ment affecté et puisse être exécuté.
• Con­trol­ler Manager : il orchestre les dif­fé­rents con­trô­leurs, qui sont des processus veillant à la stabilité du cluster. Par exemple, il réagit au­to­ma­ti­que­ment lorsqu’un nœud tombe en panne. De manière générale, il compare en continu l’état actuel du cluster avec l’état souhaité et déclenche les ajus­te­ments né­ces­saires.
• etcd : etcd est une base de données clé-valeur dis­tri­buée qui stocke toutes les données critiques du cluster (con­fi­gu­ra­tion, état, mé­ta­don­nées). On peut la con­si­dé­rer comme la mémoire de Ku­ber­netes.

Nœud de travail

Chaque cluster Ku­ber­netes possède au moins un nœud de travail, mais le plus souvent plusieurs. Ces nœuds exécutent les ap­pli­ca­tions et charges de travail qui leur sont at­tri­buées par le plan de contrôle.

Un nœud de travail comprend prin­ci­pa­le­ment deux com­po­sants es­sen­tiels :

• Kubelet : l’agent qui garantit que chaque conteneur d’un pod est cor­rec­te­ment exécuté. Pour ce faire, le Kubelet interagit avec le moteur de conteneur utilisé (par ex. con­tai­nerd ou CRI-O), chargé de créer et gérer les con­te­neurs.
• Kube-Proxy : le composant réseau qui applique les règles définies et assure la re­di­rec­tion du trafic. Il gère le routage des con­nexions vers les pods et permet la ré­par­ti­tion de charge au sein du cluster.

Comment créer un cluster Ku­ber­netes ?

Un cluster Ku­ber­netes peut être déployé aussi bien sur des machines vir­tuelles que sur des serveurs physiques. Pour mettre en place votre propre cluster, plusieurs solutions existent en fonction de vos besoins.

Con­fi­gu­rer un cluster Ku­ber­netes avec Minikube

Pour créer un cluster simple avec un seul nœud de travail, vous pouvez utiliser Minikube. Cet outil permet d’exécuter Ku­ber­netes lo­ca­le­ment sur votre or­di­na­teur à des fins de test ou d’ap­pren­tis­sage. Minikube est com­pa­tible avec tous les systèmes d’ex­ploi­ta­tion courants et son ins­tal­la­tion est décrite en détail dans de nombreux tutoriels Ku­ber­netes. Une fois installé, vous pouvez vérifier que Minikube fonc­tionne cor­rec­te­ment avec la commande suivante dans votre terminal :

minikube version

Avec l’ins­truc­tion suivante, vous démarrez Minikube :

minikube start

Après avoir exécuté cette commande, Minikube démarre une machine virtuelle dans laquelle un cluster Ku­ber­netes est au­to­ma­ti­que­ment ini­tia­lisé. Pour interagir avec le cluster, vous devez utiliser l’outil en ligne de commande kubectl. Vous pouvez vérifier si celui-ci est installé en exécutant la commande suivante dans votre terminal :

kubectl version

Vous pouvez afficher les détails de votre cluster avec la commande suivante :

kubectl cluster-info

Vous pouvez également consulter di­rec­te­ment dans le terminal les nœuds in­di­vi­duels sur lesquels vos ap­pli­ca­tions peuvent s’exécuter :

kubectl get nodes

Créer un cluster Ku­ber­netes avec kind

Si vous souhaitez créer un cluster Ku­ber­netes avec plus d’un nœud, vous pouvez utiliser l’outil kind. Kind est également dis­po­nible pour tous les systèmes d’ex­ploi­ta­tion courants. L’ins­tal­la­tion est la plus simple via un ges­tion­naire de paquets. Dans les exemples présentés ici, choco est utilisé pour Windows :

choco install kind

Pour un cluster avec plusieurs nœuds de travail, créez un fichier de con­fi­gu­ra­tion YAML dans un ré­per­toire de votre choix. Ce fichier définit la topologie de votre cluster. Voici, par exemple, un fichier de con­fi­gu­ra­tion pour un cluster Ku­ber­netes com­pre­nant un plan de contrôle et deux nœuds de travail :

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker

Ensuite, vous pouvez créer le cluster Ku­ber­netes selon la con­fi­gu­ra­tion que vous avez choisie avec la commande suivante :

kind create cluster --config exemple-fichier.yaml