# Clusters Kubernetes : explication et création

Un cluster Kubernetes est un ensemble comprenant au moins un plan de contrôle et plusieurs nœuds de travail sur lesquels sont exécutées des applications conteneurisées. Le cluster gère automatiquement le déploiement, la mise à l’échelle et la tolérance aux pannes des conteneurs. Cette architecture permet d’exécuter les applications de manière fiable et efficace dans des environnements distribués.

## Qu’est-ce qu’un cluster Kubernetes ?

Un cluster est généralement un **ensemble d’ordinateurs** qui fonctionnent comme une seule entité vue de l’extérieur. Dans [Kubernetes](https://www.ionos.fr/digitalguide/serveur/know-how/kubernetes/), ce sont plusieurs **nœuds** (*nodes*) qui sont regroupés en cluster plutôt que des ordinateurs physiques. Ces nœuds peuvent être des machines physiques ou des [machines virtuelles](https://www.ionos.fr/digitalguide/serveur/know-how/machine-virtuelle/).

Il **exécute les applications conteneurisées** et représente le **niveau le plus élevé** de l’architecture Kubernetes.

## Quels sont les cas d’utilisation des clusters Kubernetes ?

Les clusters sont un élément essentiel pour exploiter pleinement les avantages de Kubernetes. Ils permettent de déployer vos applications **sans dépendre de machines spécifiques**. En pratique, ils assurent l’abstraction des conteneurs et leur exécution sur plusieurs ordinateurs. De plus, ils ne sont pas liés à un système d’exploitation particulier, ce qui les rend **hautement portables**.

Domaines d’application typiques :

- **Déploiement d’applications complètes :** ces applications sont composées de plusieurs conteneurs et indépendantes du matériel sous-jacent. Cela permet de déployer rapidement des mises à jour ou de nouvelles fonctionnalités sans modifier de serveurs individuels, tout en garantissant une exécution cohérente dans chaque environnement.
- **Fonctionnement dans des architectures de microservices :** les applications peuvent communiquer entre elles et restent hautement évolutives. Les [microservices](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/architecture-microservices/) peuvent être développés, mis à jour et mis à l’échelle indépendamment les uns des autres, ce qui renforce l’agilité et la résilience de l’ensemble de l’application.
- **Continuous Integration (CI) et Continuous Delivery (CD) :** les processus d’[intégration continue](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/integration-continue/) et de [livraison continue](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/continuous-delivery/) automatisent le *build*, les tests et le déploiement. Cela réduit les cycles de développement, limite les erreurs manuelles et permet de mettre plus rapidement en production de nouvelles fonctionnalités ou correctifs.

## De quoi se compose un cluster Kubernetes ?

Un cluster Kubernetes 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 Kubernetes. Il est chargé de la gestion et du pilotage global. Son rôle principal est de maintenir l’**état souhaité** du cluster, en déterminant par exemple quelles applications doivent s’exécuter, où et quand. Il se compose de plusieurs éléments clés :

- **API Server :** le [serveur API](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/quest-ce-quune-api/) est l’interface centrale du plan de contrôle. Il coordonne la communication avec le cluster et définit l’état du système. L’interaction avec l’API Kubernetes est possible via la ligne de commande (`kubectl`) ou via des [interfaces graphiques](https://www.ionos.fr/digitalguide/sites-internet/web-design/interface-graphique-pour-une-ergonomie-web-optimale/), comme la console Google Cloud.
- **Scheduler** : il répartit les *pods* sur les nœuds en fonction des ressources disponibles. Il veille à ce que chaque [pod Kubernetes](https://www.ionos.fr/digitalguide/serveur/configuration/kubernetes-pod/) (groupe de conteneurs) soit correctement affecté et puisse être exécuté.
- **Controller Manager :** il orchestre les différents contrôleurs, qui sont des processus veillant à la stabilité du cluster. Par exemple, il réagit automatiquement 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 ajustements nécessaires.
- **etcd :** [etcd](https://www.ionos.fr/digitalguide/hebergement/aspects-techniques/quest-ce-quetcd/) est une [base de données clé-valeur](https://www.ionos.fr/digitalguide/hebergement/aspects-techniques/key-value-store/) distribuée qui stocke toutes les données critiques du cluster (configuration, état, métadonnées). On peut la considérer comme la mémoire de Kubernetes.

### Nœud de travail

Chaque cluster Kubernetes possède au moins un **nœud de travail**, mais le plus souvent plusieurs. Ces nœuds exécutent les **applications et charges de travail** qui leur sont attribuées par le plan de contrôle.

Un nœud de travail comprend principalement deux composants essentiels :

- **Kubelet :** l’agent qui garantit que **chaque conteneur d’un pod** est correctement exécuté. Pour ce faire, le Kubelet interagit avec le moteur de conteneur utilisé (par ex. containerd ou CRI-O), chargé de créer et gérer les conteneurs.
- **Kube-Proxy :** le composant réseau qui applique les règles définies et assure la redirection du trafic. Il gère le routage des connexions vers les pods et permet la répartition de charge au sein du cluster.

## Comment créer un cluster Kubernetes ?

Un cluster Kubernetes peut être déployé aussi bien sur des machines virtuelles que sur des serveurs physiques. Pour mettre en place votre propre cluster, plusieurs solutions existent en fonction de vos besoins.

### Configurer un cluster Kubernetes avec Minikube

Pour créer un cluster simple avec un seul nœud de travail, vous pouvez utiliser [Minikube](https://www.ionos.fr/digitalguide/serveur/outils/minikube-de-kubernetes/). Cet outil permet d’exécuter Kubernetes localement sur votre ordinateur à des fins de test ou d’apprentissage. Minikube est compatible avec tous les systèmes d’exploitation courants et son installation est décrite en détail dans de nombreux [tutoriels Kubernetes](https://www.ionos.fr/digitalguide/serveur/configuration/tutoriel-kubernetes/). Une fois installé, vous pouvez vérifier que Minikube fonctionne correctement avec la commande suivante dans votre terminal :

```bash
minikube version
```

Avec l’instruction suivante, vous démarrez Minikube :

```bash
minikube start
```

Après avoir exécuté cette commande, Minikube démarre une **machine virtuelle** dans laquelle un cluster Kubernetes est automatiquement initialisé. 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 :

```bash
kubectl version
```

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

```bash
kubectl cluster-info
```

Vous pouvez également consulter directement dans le terminal les nœuds individuels sur lesquels vos applications peuvent s’exécuter :

```bash
kubectl get nodes
```

### Créer un cluster Kubernetes avec kind

Si vous souhaitez créer un cluster Kubernetes avec **plus d’un nœud**, vous pouvez utiliser l’outil [kind](https://kind.sigs.k8s.io/docs/user/quick-start/ "kind – Quick Start"). Kind est également disponible pour tous les systèmes d’exploitation courants. L’installation est la plus simple via un gestionnaire de paquets. Dans les exemples présentés ici, choco est utilisé pour Windows :

```bash
choco install kind
```

Pour un cluster avec plusieurs nœuds de travail, créez un fichier de configuration [YAML](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/quest-ce-que-yaml/) dans un répertoire de votre choix. Ce fichier définit la **topologie de votre cluster**. Voici, par exemple, un fichier de configuration pour un cluster Kubernetes comprenant un plan de contrôle et deux nœuds de travail :

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

Ensuite, vous pouvez créer le cluster Kubernetes selon la configuration que vous avez choisie avec la commande suivante :

```none
kind create cluster --config exemple-fichier.yaml
```


This is a markdown version of: [https://www.ionos.fr/digitalguide/serveur/know-how/cluster-kubernetes/](https://www.ionos.fr/digitalguide/serveur/know-how/cluster-kubernetes/) for AI/LLM consumption.