Déployer un cluster Kubernetes K3s léger et performant pour production

K3s est une distribution Kubernetes légère développée par Rancher, consommant moins de 512 Mo de RAM. Idéal pour l'edge computing, les environnements IoT ou les infrastructures à ressources limitées, K3s simplifie drastiquement le déploiement tout en conservant la compatibilité totale avec Kubernetes.

Prérequis

Avant de commencer, assurez-vous d'avoir :

• 3 serveurs minimum (Debian 12, Ubuntu 22.04 ou Rocky Linux 9)
• 2 vCPU et 2 Go RAM par nœud (4 Go recommandé pour les masters)
• Réseau privé entre les nœuds (1 GbE minimum)
• Accès root ou sudo
• Ports ouverts : 6443 (API), 443/80 (Ingress), 10250 (Kubelet)

Architecture du cluster

Notre cluster comportera :

• 3 nœuds server (control-plane avec etcd intégré)
• 2+ nœuds agent (workers)
• Stockage distribué avec Longhorn
• Ingress Traefik avec TLS automatique via cert-manager

Installation du premier nœud server

Préparation du système

# Mise à jour et désactivation du swap
sudo apt update && sudo apt upgrade -y
sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

# Installation des dépendances
sudo apt install -y curl open-iscsi nfs-common

Installation de K3s en mode cluster

curl -sfL https://get.k3s.io | sh -s - server \
  --cluster-init \
  --write-kubeconfig-mode 644 \
  --disable traefik \
  --tls-san=k3s.votre-domaine.com \
  --node-taint CriticalAddonsOnly=true:NoExecute

Explications :

• --cluster-init : active etcd embarqué pour haute disponibilité
• --disable traefik : on installera une version récente manuellement
• --tls-san : ajoute un SAN au certificat de l'API
• --node-taint : empêche les workloads utilisateur sur les masters

Récupération du token

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

Conservez ce token pour ajouter les autres nœuds.

Ajout des nœuds server supplémentaires

Sur les serveurs 2 et 3 :

curl -sfL https://get.k3s.io | sh -s - server \
  --server https://192.168.1.10:6443 \
  --token K10xyz... \
  --write-kubeconfig-mode 644 \
  --disable traefik \
  --node-taint CriticalAddonsOnly=true:NoExecute

Vérifier le cluster :

sudo k3s kubectl get nodes

Ajout des nœuds agent (workers)

Sur chaque worker :

curl -sfL https://get.k3s.io | K3S_URL=https://192.168.1.10:6443 \
  K3S_TOKEN=K10xyz... sh -

Vérification :

sudo k3s kubectl get nodes -o wide

Configuration de kubectl en local

Sur votre poste de travail :

# Copier le kubeconfig depuis le master
scp user@192.168.1.10:/etc/rancher/k3s/k3s.yaml ~/.kube/k3s-config

# Éditer et remplacer 127.0.0.1 par l'IP réelle
sed -i 's/127.0.0.1/192.168.1.10/g' ~/.kube/k3s-config

# Utiliser le contexte
export KUBECONFIG=~/.kube/k3s-config
kubectl get nodes

Installation de Longhorn (stockage distribué)

kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/v1.5.3/deploy/longhorn.yaml

# Vérifier le déploiement
kubectl get pods -n longhorn-system -w

Définir Longhorn comme StorageClass par défaut :

kubectl patch storageclass longhorn -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'

Accéder au dashboard Longhorn :

kubectl port-forward -n longhorn-system svc/longhorn-frontend 8080:80

URL : http://localhost:8080

Installation de Traefik v3

Créer le namespace :

kubectl create namespace traefik

Ajouter le repo Helm :

helm repo add traefik https://traefik.github.io/charts
helm repo update

Installer Traefik :

helm install traefik traefik/traefik \
  --namespace traefik \
  --set ports.web.exposedPort=80 \
  --set ports.websecure.exposedPort=443 \
  --set service.type=LoadBalancer

Installation de cert-manager

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.13.3/cert-manager.yaml

# Attendre que les pods soient prêts
kubectl get pods -n cert-manager -w

Créer un ClusterIssuer Let's Encrypt :

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: admin@votre-domaine.com
    privateKeySecretRef:
      name: letsencrypt-prod
    solvers:
    - http01:
        ingress:
          class: traefik

kubectl apply -f clusterissuer.yaml

Déploiement d'une application de test

Créer un fichier nginx-demo.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-demo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-demo
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-demo
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  ingressClassName: traefik
  tls:
  - hosts:
    - demo.votre-domaine.com
    secretName: nginx-tls
  rules:
  - host: demo.votre-domaine.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-demo
            port:
              number: 80

kubectl apply -f nginx-demo.yaml

Tester : https://demo.votre-domaine.com

Sauvegarde et restauration

Sauvegarde etcd

sudo k3s etcd-snapshot save --name backup-$(date +%Y%m%d)

Les snapshots sont dans /var/lib/rancher/k3s/server/db/snapshots/

Restauration

sudo k3s server --cluster-reset --cluster-reset-restore-path=/var/lib/rancher/k3s/server/db/snapshots/backup-20251216

Comparaison K3s vs K8s classique

Avantages de K3s pour la production

1. Empreinte légère : Idéal pour edge et environnements contraints
2. Simplicité : Installation en une commande, maintenance réduite
3. Haute disponibilité native : etcd embarqué, pas de dépendances externes
4. Compatibilité totale : Tous les workloads Kubernetes fonctionnent
5. Performance : Optimisé pour les petites infrastructures (< 100 nœuds)
6. Support actif : Maintenu par SUSE/Rancher avec mises à jour régulières

Quand préférer une alternative ?

• Kubernetes classique : Clusters > 100 nœuds, exigences enterprise strictes
• K0s : Si vous préférez une approche plus modulaire
• MicroK8s : Pour du développement local rapide sur Ubuntu

Monitoring et observabilité

Installer Prometheus et Grafana :

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring --create-namespace

Accéder à Grafana :

kubectl port-forward -n monitoring svc/prometheus-grafana 3000:80

Login par défaut : admin / prom-operator

Sécurisation du cluster

Activer les Network Policies

kubectl apply -f https://raw.githubusercontent.com/k3s-io/k3s/master/manifests/calico.yaml

Configurer RBAC strict

Créer un ServiceAccount limité :

apiVersion: v1
kind: ServiceAccount
metadata:
  name: deploy-user
  namespace: default
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: deploy-role
rules:
- apiGroups: ["apps"]
  resources: ["deployments"]
  verbs: ["get", "list", "create", "update"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: deploy-binding
subjects:
- kind: ServiceAccount
  name: deploy-user
roleRef:
  kind: Role
  name: deploy-role
  apiGroup: rbac.authorization.k8s.io

Mise à jour du cluster

K3s se met à jour facilement :

# Sur chaque nœud
curl -sfL https://get.k3s.io | INSTALL_K3S_VERSION=v1.28.5+k3s1 sh -

# Vérifier la version
k3s --version

Pour les clusters critiques, utilisez le système upgrade controller :

kubectl apply -f https://github.com/rancher/system-upgrade-controller/releases/latest/download/system-upgrade-controller.yaml

Troubleshooting

Les pods ne démarrent pas

kubectl describe pod <pod-name>
kubectl logs <pod-name>

Problème de réseau

# Vérifier les CNI
kubectl get pods -n kube-system
# Redémarrer flannel
kubectl delete pod -n kube-system -l app=flannel

Node NotReady

sudo systemctl status k3s
sudo journalctl -u k3s -f

Conclusion

K3s offre une solution Kubernetes production-ready avec une complexité réduite et des performances optimisées. En suivant ce guide, vous disposez maintenant d'un cluster hautement disponible, sécurisé et prêt à héberger vos applications cloud-native. La simplicité d'installation et de maintenance fait de K3s un choix judicieux pour les équipes cherchant à adopter Kubernetes sans la surcharge opérationnelle des distributions complètes.