Thibaut DEMARET

CTO

Déploiement d’un cluster Kubernetes K3s sur 5 Raspberry Pi 3 avec DNS et DHCP intégrés transportable

Ce guide explique comment créer un cluster Kubernetes autonome avec k3s sur 5 Raspberry Pi 3, en intégrant des services DNS et DHCP open source. L’objectif est de fournir une infrastructure légère, évolutive et entièrement automatisée pour héberger vos applications conteneurisées, et transportable. Il fait parti d’un ensemble de cinq articles pour un système d’information de voyage.

Introduction

Ce guide vous présente la mise en place d’un cluster Kubernetes basé sur K3S sur 5 Raspberry Pi 3. Ce cluster intègre en natif des services DNS et DHCP, offrant ainsi une solution totalement autonome, full Open Source et accessible via ligne de commande et SSH. L’approche vise à automatiser la configuration réseau et la gestion des noeuds pour répondre aux contraintes d’un environnement à ressources limitées et transportable.

Prérequis

Matériel

  • 5 Raspberry Pi 3 (modèles B/B+ recommandés, avec au moins 1 Go de RAM chacun)
  • Câbles Ethernet et un switch Gigabit pour relier les noeuds
  • Alimentations stables (5V/2.5A de préférence)
  • Cartes microSD de 16 Go minimum (une par noeud)

Logiciel

  • Raspberry Pi OS Lite (version 64 bits recommandée pour de meilleures performances)
  • Outils requis en CLI :
    • kubectl, curl
    • SSH configuré sur chaque Raspberry Pi
  • Accès root ou sudo sur chaque nœud pour l’installation et la configuration

Étapes détaillées du déploiement

1. Configuration réseau et IP statiques

Attribution d’IP statiques

Pour assurer la stabilité de la communication entre vos nœuds, configurez des adresses IP fixes.

  • Via le routeur : Réservez une plage d’IP pour vos Raspberry Pi (par exemple, de 192.168.1.101 à 192.168.1.105).

  • Ou directement dans chaque noeud : Modifiez le fichier /etc/dhcpcd.conf sur chaque Raspberry Pi :

    sudo vim /etc/dhcpcd.conf

    Ajoutez la configuration suivante pour l’interface eth0 (adaptez l’IP selon le nœud) :

    interface eth0
static ip_address=192.168.1.101/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1

  • Redémarrez le service réseau :

    sudo systemctl restart dhcpcd

2. Désactivation du swap et configuration des cgroups

2.1. Désactivation du swap

Pour éviter toute interférence avec le runtime de K3s :

sudo swapoff -a  # Désactivation immédiate

Pour une désactivation permanente, éditez le fichier /etc/fstab et supprimez ou commentez la ligne liée au swap.

2.2. Configuration des cgroups pour Kubernetes

Kubernetes a besoin que les cgroups soient configurés correctement. Sur Raspberry Pi OS Lite, modifiez le fichier /boot/cmdline.txt :

sudo vim /boot/cmdline.txt

Ajoutez à la fin de la ligne existante :

cgroup_memory=1 cgroup_enable=memory

Puis redémarrez :

sudo reboot

3. Installation de K3s et création du cluster

3.1. Installation sur le nœud maître

Sur l’un des Raspberry Pi (celui destiné à être le master), exécutez :

curl -sfL https://get.k3s.io | sh -

Une fois l’installation terminée, récupérez le token d’authentification :

sudo cat /var/lib/rancher/k3s/server/node-token

Notez ce token (ex. : K10c3d4...::server:abcd1234) pour connecter vos noeuds workers.

3.2. Installation sur les noeuds workers

Sur chaque Raspberry Pi destiné à être worker, lancez :

curl -sfL https://get.k3s.io | K3S_URL=https://<IP_MASTER>:6443 K3S_TOKEN=<TOKEN> sh -

Remplacez par l'adresse IP du master et par le token obtenu.

3.3. Vérification du cluster

Depuis le nœud master ou via SSH, vérifiez que l’ensemble des nœuds apparaît bien :

kubectl get nodes

L’affichage doit lister les 5 nœuds en état Ready.

4. Déploiement des services DNS et DHCP

Afin de gérer le routage et la distribution des adresses IP, nous allons intégrer des solutions open source pour le DNS et le DHCP.

4.1. Déploiement de Pi-hole pour le DNS

  1. Installation de Helm :

    curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

  2. Ajout du dépôt Helm pour Pi-hole :

    helm repo add mojo2600 https://mojo2600.github.io/pihole-kubernetes/
helm repo update

  3. Déploiement de Pi-hole :

    Personnalisez un fichier values.yaml selon vos besoins (par exemple, pour définir le domaine, les IP statiques, etc.) puis :

    helm install pihole mojo2600/pihole -f values.yaml

4.2. Configuration du service DHCP avec MetalLB

Pour exposer les services et gérer la distribution IP via MetalLB :

  1. Installation de MetalLB :

    kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.13.10/config/manifests/metallb-native.yaml

  2. Création d’un pool d’IP pour MetalLB en créant un fichier de configuration (par exemple, metallb-config.yaml) :

    apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: dhcp-pool
spec:
  addresses:
  - 192.168.1.200-192.168.1.250

    Appliquez la configuration avec :

    kubectl apply -f metallb-config.yaml

Certains déploiements DHCP utilisent des solutions complémentaires comme kube-vip pour fournir une haute disponibilité au niveau du control plane.

5. Connexion au NAS pour stockage persistant

Pour étendre les capacités de notre cluster, vous pouvez intégrer un NAS en tant que stockage persistant.
Dans cet exemple, nous utiliserons un NAS déployé précédemment (avec ZFS et LUKS sur Raspberry Pi) qui expose ses données via NFS.

5.1. Configuration du serveur NFS sur le NAS

  1. Installation du serveur NFS sur votre NAS :

    sudo apt update
sudo apt install -y nfs-kernel-server

  2. Export du dataset ZFS
    Supposons que votre pool ZFS possède un dataset dédié, par exemple naspool/data. Éditez le fichier /etc/exports pour ajouter une ligne d’export :

    sudo vim /etc/exports

    Ajoutez par exemple :

    /naspool/data 192.168.1.0/24(rw,sync,no_subtree_check)

  3. Rechargez la configuration NFS :

    sudo exportfs -ra

5.2. Intégration du partage NFS dans K3s

  1. Installation du provisioner NFS
    Vous pouvez utiliser un provisioner dynamique pour NFS (par exemple, le NFS Client Provisioner) afin de gérer les volumes persistants automatiquement.
    Commencez par créer un namespace et déployer le provisioner :

    kubectl create namespace nfs-provisioner
helm repo add stable https://charts.helm.sh/stable
helm repo update
helm install nfs-client-provisioner stable/nfs-client-provisioner \
  --namespace nfs-provisioner \
  --set nfs.server=<IP_NAS> \
  --set nfs.path=/naspool/data

    Remplacez par l’adresse IP du NAS hébergeant le partage NFS.

  2. Création d’un StorageClass pour NFS

    Créez un fichier nfs-storageclass.yaml :

    apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs
provisioner: stable/nfs-client-provisioner
reclaimPolicy: Delete
mountOptions:
  - hard
  - nfsvers=4.1

    Appliquez-le :

    kubectl apply -f nfs-storageclass.yaml

  3. Utilisation dans vos déploiements Kubernetes

    Vous pourrez désormais définir des PersistentVolumeClaims (PVC) dans vos applications en précisant le StorageClass nommé nfs :

    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mon-pvc
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: nfs
  resources:
    requests:
      storage: 2Gi

    Ce PVC utilisera le stockage fourni par le NAS via NFS.

6. Tests et optimisations

6.1. Vérification des services

  • Cluster Kubernetes :
    Vérifiez la santé de vos nœuds et services avec :

    kubectl get nodes
kubectl get svc -A

  • Service DNS :
    Assurez-vous que Pi-hole est opérationnel et que les requêtes DNS sont traitées correctement.

  • Service DHCP :
    Vérifiez via MetalLB ou kube-vip que votre cluster peut attribuer les adresses IP selon votre configuration.

6.2. Optimisations

  • Limitation des ressources :
    Pour les Raspberry Pi, il peut être judicieux d’ajuster la mémoire allouée aux conteneurs et de surveiller l’utilisation CPU pour éviter toute surcharge.

  • Redondance et résilience :
    Déployer kube-vip sur le control plane peut améliorer la haute disponibilité en cas de défaillance du noeud maître.

Conclusion

Ce guide vous a présenté comment déployer un cluster Kubernetes K3S sur 5 Raspberry Pi 3, intégrant des services DNS et DHCP en utilisant des outils Open Source. L’approche full CLI et SSH permet une administration fine et entièrement automatisée, idéale pour les environnements contraints.

Cet article est conçu pour offrir une solution robuste et légère qui rend faisable un petit datacenter transportable et indépendant.

Notre série sur un SI de voyage hautement sécurisé

Si vous ne les avez pas encore lu, retrouvez notre série d’articles sur la conception un Système d’Information transportable :

Vous pourriez aimer aussi