# DaemonSet Kubernetes : gestion efficace des clusters

Les DaemonSets Kubernetes facilitent la gestion des applications ou services qui doivent être exécutés sur chaque nœud. La configuration et les modifications d’un DaemonSet sont automatiquement appliquées à tous les nœuds.

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

Les DaemonSets Kubernetes sont des ressources qui garantissent l’exécution d’au moins une instance d’un pod donné sur chaque nœud du cluster. L’application ou le service est ainsi **globalement présent dans tout l’environnement du cluster**. Les DaemonSets sont particulièrement adaptés aux tâches telles que la surveillance, la journalisation ou les services réseau qui doivent être présents sur chaque nœud du cluster. L’un des principaux avantages des DaemonSets est leur scalabilité, car ils démarrent automatiquement et suppriment les pods existants lorsque les nœuds tombent en panne ou sont supprimés. Les DaemonSets améliorent ainsi la sécurité contre les pannes et facilitent la gestion du cluster.

Conseil Avec la solution Cloud [Managed Kubernetes](https://cloud.ionos.fr/managed/kubernetes "Hébergement de Kubernetes géré - créez votre prochain cluster avec IONOS") de IONOS, vous bénéficiez d’une configuration de cluster entièrement automatisée ainsi que de charges de travail hautement performantes et d’une sécurité contre les pannes.

## Configuration d’un DaemonSet Kubernetes

La distribution des pods peut être contrôlée de manière granulaire sur la base des **propriétés des nœuds, des besoins en ressources** ou d’autres critères définis par l’utilisateur. Nous vous expliquons ci-dessous comment configurer et utiliser un DaemonSet.

### Créer un fichier YAML DaemonSet

Tout d’abord, vous devez définir la configuration du DaemonSet dans un **fichier YAML**. Ce fichier contient des informations telles que le nom du DaemonSet, le type de pod utilisé et les paramètres spécifiques pour le placement sur les nœuds.

Voici un exemple de fichier YAML qui crée un pod avec un conteneur NGINX sur chaque nœud :

```yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
    name: nginx-daemonset
spec:
    selector:
        matchLabels:
            app: nginx
    template:
        metadata:
            labels:
                app: nginx
        spec:
            containers:
            - name: nginx-container
                image: nginx:latest
```

### Activer la configuration YAML

Ouvrez votre ligne de commande et accédez au répertoire dans lequel se trouve votre fichier DaemonSet YAML. Exécutez ensuite la commande `kubectl apply` pour appliquer la configuration à votre **cluster Kubernetes** :

```shell
kubectl apply -f daemonset.yaml
```

Cette commande indique au cluster Kubernetes de créer ou de mettre à jour les ressources définies dans le fichier YAML.

### Vérifier le DaemonSet Kubernetes

Vous devez contrôler si les pods souhaités ont été lancés avec succès sur chaque nœud.

```shell
kubectl get daemonset
```

La sortie de cette commande contient des informations importantes, dont :

- `DESIRED` : le nombre souhaité de pods à créer par le DaemonSet.
- `CURRENT` : le nombre réel de pods fournis.
- `READY` : le nombre de pods déployés qui sont prêts à être utilisés.
- `UP-TO-DATE` : le nombre de pods qui sont actuellement à jour par rapport à la configuration du DaemonSet.
- `AVAILABLE` : le nombre de pods opérationnels qui ne sont pas affectés par d’autres ressources, telles que les affinités ou les tolérances.
- `NODE SELECTOR` : les étiquettes pour les nœuds sur lesquels le DaemonSet doit fonctionner (si configuré).
- `AGE` : quand le DaemonSet a été créé.

Dans notre exemple, vous voyez que le DaemonSet Kubernetes `nginx-daemonset` a trois pods souhaités et que trois pods sont en cours d’exécution sur les nœuds.

```shell
NAME                      DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
nginx-daemonset              3         3        3         3            3          <none>       5m
```

### Vérifier les pods

Pour obtenir une vue plus détaillée des pods créés, utilisez cette commande :

```shell
kubectl get pods
```

La sortie montre l’état des pods, y compris l’état de préparation, l’état actuel et le temps d’exécution.

```shell
NAME                      READY   STATUS    RESTARTS       AGE
nginx-daemonset-abcde     1/1      Running      0          5m
nginx-daemonset-fghij     1/1      Running      0          5m
nginx-daemonset-klmno     1/1      Running      0          5m
```

### Supprimer le DaemonSet

Tout d’abord, vous devez vérifier quels DaemonSets sont présents dans votre cluster. Tapez la commande `kubectl delete daemonset` suivie du nom du DaemonSet à supprimer dans la console. Par exemple :

```shell
kubectl delete daemonset nginx-daemonset
```

### Limiter les DaemonSets Kubernetes à des nœuds spécifiques

Pour exécuter des DaemonSets sur des nœuds spécifiques dans un cluster Kubernetes, vous pouvez utiliser des sélecteurs de nœuds ou des affinités dans la configuration DaemonSet. Cela vous permet de définir les nœuds sur lesquels les pods DaemonSet doivent être créés.

```yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
    name: nginx-daemonset
spec:
    selector:
        matchLabels:
            app: nginx
    template:
        metadata:
            labels:
                app: nginx
        spec:
            nodeSelector:
                custom-label: special-node
            containers:
            - name: nginx-container
                image: nginx:latest
```

Dans cet exemple, le DaemonSet est configuré pour ne fonctionner que sur les nœuds avec l’étiquette `custom-label : special-node`.

### Communiquer avec les pods DaemonSet

La communication avec les pods Daemon dans Kubernetes peut se faire de différentes manières, en fonction des besoins de votre application.

- **Push** : dans ce scénario, les pods DaemonSet envoient activement des données ou des mises à jour à un service externe. Ce service externe pourrait être, par exemple, une base de données statistique ou un système de log central. Les pods DaemonSet eux-mêmes n’ont pas de clients et n’initient pas de connexions entrantes.
- **NodeIP et port connu** : avec cette méthode, chaque pod DaemonSet utilise un port spécifique sur le nœud pour être accessible. Les clients connaissent la liste des IP de nœuds disponibles et atteignent les pods par l’IP de nœud et le port correspondant.
- **DNS** : en utilisant un `__headless service__` avec le même sélecteur de pod que le DaemonSet Kubernetes, vous pouvez activer une résolution DNS pour les pods individuels. Les clients peuvent alors communiquer avec les pods DaemonSet en utilisant la ressource Endpoints ou en récupérant plusieurs enregistrements A dans le DNS.
- **Service** : la création d’un service Kubernetes régulier avec le même sélecteur de pod permet aux clients d’accéder aux pods DaemonSet. Cela se fait via l’adresse IP du cluster du service. Notez que cela ne garantit pas l’accès à un nœud spécifique. Au lieu de cela, le service transmettra la demande à l’un des pods DaemonSet disponibles.

Vous trouverez des informations détaillées sur la gestion des clusters pour les débutants dans notre [tutoriel Kubernetes](https://www.ionos.fr/digitalguide/serveur/configuration/tutoriel-kubernetes/).


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