K3s : Kubernetes leger sur Proxmox pour les PME

Kubernetes fait peur. Et honnêtement, pendant longtemps j'ai compris pourquoi — des dizaines de composants, des YAMLs à n'en plus finir, une courbe d'apprentissage brutale. K3s a changé ma perspective. En 5 minutes, vous avez un cluster Kubernetes fonctionnel. Ce guide vous montre comment déployer K3s sur Proxmox, configurer un stockage persistant, et déployer vos premières applications en production.

Pourquoi K3s pour les PME ?

K3s est Kubernetes complet, mais empaqueté dans un binaire unique de 60 MB. Il enlève les composants rarement utilisés en production (drivers cloud AWS/Azure/GCP, APIs legacy) et les remplace par des équivalents légers. Résultat : fonctionne sur un Raspberry Pi 4, ou dans des VMs Proxmox à 2 vCPU / 2 GB RAM.

• Binaire unique : pas de dépendances à installer, déploiement trivial
• SQLite par défaut : pour les petits clusters, pas besoin d'etcd séparé
• Traefik intégré : ingress controller HTTP prêt à l'emploi
• Containerd : runtime de conteneurs léger (pas Docker obligatoire)
• ARM64 supporté : fonctionne sur Raspberry Pi pour les labs
• HA disponible : cluster haute disponibilité si 3+ nodes

Préparer les VMs Proxmox

On va créer 3 VMs dans Proxmox : 1 master (control plane) + 2 workers. Pour la production, utilisez 3 masters pour la HA.

Configuration des VMs recommandée

• VM Master : 2 vCPU, 4 GB RAM, 40 GB SSD (peut être 2 GB RAM pour un lab)
• VM Worker x2 : 4 vCPU, 8 GB RAM, 80 GB SSD (adaptez à vos charges)
• OS : Ubuntu Server 22.04 LTS ou 24.04 LTS
• Réseau : bridge virtio, IPs fixes (ou réservations DHCP)
• Stockage Proxmox : LVM-Thin ou ZFS recommandé pour les snapshots

# Sur CHAQUE VM (master + workers) — Préparation système
# Configuration réseau static
sudo nano /etc/netplan/00-installer-config.yaml

# /etc/netplan/00-installer-config.yaml
network:
  ethernets:
    ens18:
      addresses:
        - 192.168.1.10/24  # Master: .10, Worker1: .11, Worker2: .12
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses: [1.1.1.1, 8.8.8.8]
  version: 2

sudo netplan apply

# Désactiver le swap (obligatoire pour Kubernetes)
sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

# Vérifier
free -h  # → Swap doit afficher 0

# Configurer les modules kernel requis
cat << 'EOF' | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

# Paramètres réseau Kubernetes
cat << 'EOF' | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF
sudo sysctl --system

# Mettre à jour /etc/hosts sur TOUTES les VMs
sudo nano /etc/hosts
# Ajouter :
# 192.168.1.10  k3s-master
# 192.168.1.11  k3s-worker1
# 192.168.1.12  k3s-worker2

Installation K3s — Master (Control Plane)

# Installation du master K3s (une seule commande !)
curl -sfL https://get.k3s.io | sh -s - server   --cluster-init   --tls-san 192.168.1.10   --disable traefik   --write-kubeconfig-mode 644

# Vérifier que K3s tourne
sudo systemctl status k3s
sudo kubectl get nodes

# Récupérer le token pour joindre les workers
sudo cat /var/lib/rancher/k3s/server/node-token
# → Copier ce token, vous en aurez besoin pour les workers

⚠️ Le token est sensible — ne le partagez pas publiquement et stockez-le dans votre gestionnaire de secrets (Vault, Bitwarden).

Joindre les Workers

# Sur CHAQUE worker — Rejoindre le cluster
# Remplacer <TOKEN> par le token récupéré sur le master
# Remplacer <IP_MASTER> par l'IP du master (192.168.1.10)
curl -sfL https://get.k3s.io | K3S_URL=https://<IP_MASTER>:6443   K3S_TOKEN=<TOKEN> sh -s - agent

# Vérifier sur le MASTER que les workers ont rejoint
sudo kubectl get nodes -o wide

# Output attendu :
# NAME          STATUS   ROLES                  AGE   VERSION
# k3s-master    Ready    control-plane,master   5m    v1.29.x+k3s1
# k3s-worker1   Ready    <none>                 2m    v1.29.x+k3s1
# k3s-worker2   Ready    <none>                 1m    v1.29.x+k3s1

Configuration kubectl sur votre poste local

# Sur votre machine locale (Mac, Linux, Windows WSL)
# Installer kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install kubectl /usr/local/bin/

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

# Remplacer l'IP localhost par l'IP réelle du master
sed -i 's/127.0.0.1/192.168.1.10/g' ~/.kube/config

# Tester
kubectl get nodes
kubectl cluster-info

Installer Ingress Controller Nginx + Cert-Manager

# Installer Helm (gestionnaire de packages Kubernetes)
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Installer Nginx Ingress Controller
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm install ingress-nginx ingress-nginx/ingress-nginx   --namespace ingress-nginx   --create-namespace   --set controller.service.type=LoadBalancer

# Installer Cert-Manager (certificats SSL Let's Encrypt)
helm repo add jetstack https://charts.jetstack.io
helm install cert-manager jetstack/cert-manager   --namespace cert-manager   --create-namespace   --set installCRDs=true

# Vérifier
kubectl get pods -n ingress-nginx
kubectl get pods -n cert-manager

Déployer votre première application

Déployons une application web simple avec une base de données PostgreSQL :

# Créer un namespace pour l'application
kubectl create namespace mon-app

# Déploiement PostgreSQL
cat << 'EOF' | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
  namespace: mon-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:15
        env:
        - name: POSTGRES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: postgres-secret
              key: password
        ports:
        - containerPort: 5432
        volumeMounts:
        - name: postgres-data
          mountPath: /var/lib/postgresql/data
      volumes:
      - name: postgres-data
        persistentVolumeClaim:
          claimName: postgres-pvc
EOF

# PersistentVolumeClaim pour les données PostgreSQL
cat << 'EOF' | kubectl apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
  namespace: mon-app
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
EOF

# Secret pour le mot de passe PostgreSQL
kubectl create secret generic postgres-secret   --namespace mon-app   --from-literal=password='VotreMotDePasseSecurise123!'

# Vérifier le déploiement
kubectl get pods -n mon-app
kubectl get pvc -n mon-app

Monitoring K3s avec Grafana + Prometheus

# Installer la stack kube-prometheus (tout-en-un)
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install kube-prometheus prometheus-community/kube-prometheus-stack   --namespace monitoring   --create-namespace   --set grafana.service.type=LoadBalancer   --set grafana.adminPassword='VotreMotDePasse'

# Accéder à Grafana
kubectl get svc -n monitoring
# → Trouver l'IP externe du LoadBalancer Grafana
# Dashboards pré-configurés : Cluster Overview, Pods, Nodes...

# Voir les métriques en CLI
kubectl top nodes
kubectl top pods -n mon-app

Sauvegarde de l'état du cluster

# Sauvegarder la configuration K3s (etcd / SQLite)
sudo systemctl stop k3s
sudo cp -r /var/lib/rancher/k3s/server/db /backup/k3s-db-$(date +%Y%m%d)
sudo systemctl start k3s

# Avec Velero (sauvegarde cloud Kubernetes)
helm repo add vmware-tanzu https://vmware-tanzu.github.io/helm-charts
helm install velero vmware-tanzu/velero   --namespace velero   --create-namespace   --set-json 'configuration.backupStorageLocation[0].config.region=fr-par'   --set-json 'configuration.backupStorageLocation[0].provider=aws'

# Créer un backup complet
velero backup create backup-complet --include-namespaces '*'

Prochaines étapes

• Passer à un cluster HA avec 3 masters (haute disponibilité)
• Configurer Longhorn pour le stockage distribué persistant (remplace les PVCs locaux)
• Implémenter des NetworkPolicies pour l'isolation des namespaces (Zero Trust Kubernetes)
• Mettre en place ArgoCD ou Flux pour le GitOps (déploiements automatisés depuis Git)
• Configurer un registry Docker privé avec Harbor pour vos images internes