Aller au contenu
RZ RenZan Blog Homelab · IA · Domotique
Deux barrettes de mémoire vive posées sur un fond blanc Infrastructure · 1 août 2026

La chasse au gigaoctet : 49 conteneurs et un LLM local dans 31 Go de RAM

Le serveur fait tourner 49 conteneurs, une machine virtuelle et un modèle de langage local sur 31 Go de RAM, sans swap. Quand la mémoire sature, la machine gèle sans laisser de trace. Plutôt que d'acheter des barrettes, le choix a été de réduire la demande : plafonner le cache de ZFS, quantifier le modèle de langage, borner chaque service. Voici les leviers, les chiffres et les pièges.

Le problème : la mémoire, pas le calcul

Le premier article de ce blog racontait les freezes silencieux : sans swap, un dépassement de RAM gèle la machine entière, et le redémarrage ne laisse aucune trace. La cause n'est pas la puissance de calcul : le processeur reste largement sous-utilisé, et le stockage est abondant. Le facteur limitant, c'est la RAM : 31 Go au total, dont une partie est tenue par le cache de lecture de ZFS, une autre par la machine virtuelle de domotique, une autre par le modèle de langage local.

Deux stratégies s'opposent : augmenter l'offre ou réduire la demande. La mémoire est en DDR4 sur quatre slots : passer à 64 Go représente un budget que l'optimisation logicielle rend inutile. La chasse au gigaoctet a donc commencé côté demande.

Premier levier : plafonner le cache ARC de ZFS

Le premier poste est un cache. TrueNAS réserve par défaut la moitié de la RAM physique au cache de lecture de ZFS (ARC) : sur 31 Go, jusqu'à 15 Go peuvent être mobilisés pour accélérer les lectures de disque. C'est utile, mais c'est un cache : il ne fait que retarder les lectures répétées, et la moindre pression mémoire l'évince. Le plafonner à 4 Go rend potentiellement 11 Go aux applications, sans impact perceptible sur un usage domestique.

Le réglage se vérifie directement : le compteur c_max de /proc/spl/kstat/zfs/arcstats affiche 4 294 967 296 octets, soit 4 Go exactement. En fonctionnement, l'ARC se tient autour de 2,6 Go : le plafond n'est pas une contrainte, juste une garantie.

Deuxième levier : le modèle de langage local

Le poste suivant était le plus gros : le serveur de langage local. La configuration précédente dépassait 6 Go de RAM, entre un modèle chargé entièrement en mémoire et un cache de contexte en précision pleine. Trois changements ont été appliqués :

La commande de lancement porte ces choix :

llama-server --model Ornith-1.0-9B-IQ4_XS.gguf --ctx-size 32768 \
  --n-gpu-layers 99 --cache-type-k q4_0 --cache-type-v q4_0 \
  --flash-attn on --threads 4 --alias athena

Résultat : 679 Mo de RAM mesurés après la mise en place, un peu plus d'un gigaoctet de RSS constaté en fonctionnement, et 6,4 des 8 Go de VRAM utilisés. Le processus du serveur de langage est passé d'une consommation de plus de 6 Go de RAM à un peu plus d'un gigaoctet.

Attention aux statistiques Docker : le conteneur affiche 5,6 Go consommés. La raison est que llama.cpp mappe le fichier du modèle en mémoire (page cache). Docker compte ce cache dans la consommation, alors qu'il est récupérable à tout moment. Le chiffre qui compte est le RSS du processus : un peu plus d'un gigaoctet.

Troisième levier : borner chaque service

Chaque conteneur a maintenant une limite mémoire explicite. C'est le deuxième filet de sécurité : si un service déraille, il est arrêté par son plafond au lieu de vider la machine. Quelques exemples relevés au moment de la mesure : l'agent qui orchestre le système consomme 1,1 Go sur une limite de 4 ; la reconnaissance vocale, le plus gros consommateur applicatif, 2,7 Go sur une limite de 3 ; la gestion de documents, 1,4 Go sur une limite de 1,5.

La machine virtuelle qui héberge la domotique est allouée à 4 Go, pour 2,6 Go réellement utilisés par son processus. Là encore, le réglage suit la mesure : allouer moins que l'usage réel n'a pas de sens, allouer beaucoup plus non plus.

Le résultat

Au moment de la mesure, la machine affichait 22 Go utilisés et environ 9 Go disponibles, avec zéro swap et une charge soutenue. La marge de sécurité est revenue : les pics — transcodage, batch d'indexation, requêtes au modèle de langage — sont absorbés sans toucher le mur.

Les leçons

Quatre enseignements ressortent de cette chasse au gigaoctet :

L'ordre des opérations compte : plafonner le cache d'abord, puis le plus gros consommateur, puis borner le reste. Chaque étape se mesure, et la marge se reconstruit gigaoctet par gigaoctet.

← Retour au blog