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.

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)

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

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.

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

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

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

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

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

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

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 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

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

• 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

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

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

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

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

Si vous préférez une approche plus classique, consultez notre guide d'introduction à Kubernetes et explorez le déploiement de clusters hautement disponibles. Pour une stratégie GitOps au-dessus de K3s, découvrez comment adopter GitOps avec Argo CD.

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.