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 :
- Un modèle plus petit et quantifié : Ornith 1.0 9B en quantification 4 bits (IQ4_XS), soit 9 milliards de paramètres compressés, au lieu d'un modèle plus volumineux chargé tel quel.
- Le calcul déporté sur la carte graphique : 99 couches du modèle sont exécutées sur la RTX 3060 Ti (8 Go de VRAM), seules les dernières restent sur le processeur.
- Un cache de contexte compressé : la mémoire qui mémorise les tokens (cache KV) passe de la précision 16 bits à une quantification 4 bits (
q4_0), ce qui divise par quatre sa consommation, pour une fenêtre de 32 768 tokens.
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 :
- La RAM se gagne côté demande. Avant d'acheter, il faut regarder ce qui la consomme : un cache mal plafonné, un modèle trop précis, un contexte en précision pleine.
- Les statistiques Docker comptent le cache. Un conteneur qui affiche 5,6 Go peut n'en utiliser qu'un peu plus d'un : croiser avec le RSS du processus avant de conclure.
- La quantification est le levier le plus rentable. Un modèle de 9 milliards de paramètres tient dans un peu plus d'un gigaoctet de RAM, sans perte perceptible pour les tâches du homelab.
- Une limite par service protège les voisins. Le plafond mémoire transforme un incident local en non-événement.
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