5 min read Intermediate 6.3k

K3s : Kubernetes leger production-ready

Published on May 17, 2026 at 04:47 PM

K3s est une distribution Kubernetes ultra-legere (90 Mo binaire) pour edge, IoT, ARM, dev. Production-ready, certifie CNCF, maintenue par SUSE/Rancher. Installation en une commande, dependances minimales.

Introduction

K3s est Kubernetes mais :

Binary unique 90 Mo (vs 200+ Mo pour kubeadm)
SQLite par defaut (pas besoin d'etcd cluster)
Containerd integre (pas de Docker)
Helm chart, Traefik, MetricsServer, ServiceLB inclus
Tourne sur Raspberry Pi
Certifie CNCF (conforme upstream K8s)

Cas d'usage :

Edge / IoT
Petits clusters (1-10 nodes)
Dev / Test
Single-node prod (homelab, sites perso)

Prerequis

VPS Linux Debian / Ubuntu / Rocky
1 GB RAM minimum (2 GB recommande)
Acces root

Etape 1 : Installation single-node (server)

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

Verifiez :

sudo k3s kubectl get nodes

K3s installe : kubelet, kube-apiserver, etcd/SQLite, kube-scheduler, kube-controller-manager, containerd, Traefik, Local Storage Provisioner, etc.

Etape 2 : Configurer kubectl pour votre user

mkdir -p ~/.kube
sudo cat /etc/rancher/k3s/k3s.yaml > ~/.kube/config
chmod 600 ~/.kube/config

Si vous avez kubectl installé :

kubectl get nodes

Etape 3 : Premiere app

kubectl create deployment nginx --image=nginx
kubectl expose deployment nginx --port=80 --type=LoadBalancer
kubectl get svc

K3s a un LoadBalancer integre (klipper-lb) qui fait du host-port. L'IP de votre VPS devient accessible sur le port assigné.

curl http://IP_VPS:NODE_PORT

Etape 4 : Ajouter un node worker (agent)

Recuperez le token sur le server :

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

Sur le worker node :

curl -sfL https://get.k3s.io | K3S_URL=https://IP_SERVER:6443 K3S_TOKEN=VOTRE_TOKEN sh -

Verifiez sur le server :

kubectl get nodes

Vous voyez les 2 nodes.

Etape 5 : Cluster HA (3+ servers)

Pour de la HA, deployez plusieurs servers avec etcd embedded :

Premier server :

curl -sfL https://get.k3s.io | sh -s - server --cluster-init

Server 2 et 3 :

curl -sfL https://get.k3s.io | sh -s - server --server https://IP_SERVER1:6443 --token VOTRE_TOKEN

Vous avez maintenant 3 control-plane nodes (HA via etcd).

Etape 6 : Deployer une app via YAML

monapp.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: monapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: monapp
  template:
    metadata:
      labels:
        app: monapp
    spec:
      containers:
      - name: monapp
        image: nginx:alpine
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 500m
            memory: 256Mi
---
apiVersion: v1
kind: Service
metadata:
  name: monapp
spec:
  selector:
    app: monapp
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP

kubectl apply -f monapp.yaml
kubectl get pods
kubectl get svc

Etape 7 : Ingress avec Traefik (inclus)

K3s embarque Traefik. Creez un Ingress :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: monapp-ingress
spec:
  rules:
  - host: monapp.votre-domaine.fr
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: monapp
            port:
              number: 80

kubectl apply -f ingress.yaml

Pointez le DNS de monapp.votre-domaine.fr vers l'IP du server. Acces : http://monapp.votre-domaine.fr.

Etape 8 : HTTPS auto avec cert-manager

Installez cert-manager :

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

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: [email protected]
    privateKeySecretRef:
      name: letsencrypt-prod
    solvers:
    - http01:
        ingress:
          class: traefik

kubectl apply -f issuer.yaml

Ajoutez l'annotation TLS a votre ingress :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: monapp-ingress
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  tls:
  - hosts:
    - monapp.votre-domaine.fr
    secretName: monapp-tls
  rules:
  - host: monapp.votre-domaine.fr
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: monapp
            port:
              number: 80

Cert-manager genere automatiquement le cert.

Etape 9 : Storage persistant

K3s embarque Local Path Provisioner :

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: monapp-data
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: local-path
  resources:
    requests:
      storage: 10Gi

Pour du storage replique, regardez Longhorn (storage K8s natif maintenue par Rancher).

Etape 10 : Helm

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

helm repo add bitnami https://charts.bitnami.com/bitnami
helm install monrelease bitnami/postgresql

Etape 11 : Monitoring

Installez Prometheus + Grafana :

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install kube-prom prometheus-community/kube-prometheus-stack

Acces Grafana via :

kubectl port-forward svc/kube-prom-grafana 3000:80

Credentials par defaut : admin / prom-operator.

Etape 12 : Uninstall

sudo /usr/local/bin/k3s-uninstall.sh         # sur server
sudo /usr/local/bin/k3s-agent-uninstall.sh    # sur agent

Depannage

"Unable to connect to the server"

Verifiez :

sudo systemctl status k3s

Et que kubeconfig pointe vers la bonne IP :

kubectl config view

Pods en CrashLoopBackOff

kubectl describe pod nom-du-pod
kubectl logs nom-du-pod

Souvent : image manquante, env var incorrecte, ressources insuffisantes.

Disk pressure

df -h
kubectl top nodes

K3s stocke les images et data dans /var/lib/rancher/k3s/. Augmentez le disque ou nettoyez :

sudo k3s crictl rmi --prune

Networking issues

sudo k3s check-config

Verifiez que les kernel modules sont OK.

Commandes utiles

# Status K3s
sudo systemctl status k3s
sudo systemctl restart k3s
sudo journalctl -u k3s -f

# Nodes
kubectl get nodes -o wide
kubectl describe node nom

# Pods
kubectl get pods -A
kubectl logs nom-pod -n namespace
kubectl exec -it nom-pod -- sh

# Apply / delete
kubectl apply -f fichier.yaml
kubectl delete -f fichier.yaml

# Services et ingresses
kubectl get svc -A
kubectl get ingress -A

# Tokens et certs
sudo cat /var/lib/rancher/k3s/server/node-token

# Containerd direct
sudo k3s crictl ps
sudo k3s crictl images

Conclusion

K3s vous donne Kubernetes sans la complexite :

Installation en une commande
Production-ready meme single-node
HA possible avec etcd embedded
Compatibilite full avec K8s upstream

Limites :

SQLite limit a quelques centaines de pods (utilisez etcd au-dela)
Moins de tooling integre que les gros K8s managed

Pour aller plus loin :

Utilisez Rancher pour gerer plusieurs clusters K3s
Combinez avec ArgoCD pour le GitOps
Pour edge / IoT, regardez K3OS (OS minimaliste pour K3s)

Ressources

Documentation officielle : https://docs.k3s.io
Source : https://github.com/k3s-io/k3s
Rancher : https://rancher.com
K3OS : https://k3os.io