Dans l’article précédent, j’ai fait passer Uptime Kuma de 1,36 à 0,65 Go écrits par jour. En le terminant, un autre chiffre me gênait : docker stats affichait des volumes bien plus gros pour d’autres conteneurs.
| Conteneur | Lu | Écrit |
|---|---|---|
| Nœud Storj n° 1 | 4,13 Go | 36,6 Go |
| Nœud Storj n° 2 | 4,46 Go | 36,2 Go |
| Ollama | 42,6 Go | 28,5 Go |
En 3 à 4 jours. Mon SSD système ne fait que 60 Go. La question était simple : qui écrit sur le SSD, et qui écrit sur les disques durs ?
La réponse m’a pris deux jours, six fausses pistes, et je n’ai pas du tout trouvé ce que je cherchais.
Le matériel
Pour suivre, voici les disques du serveur :
| Disque | Modèle | Rôle |
|---|---|---|
sda |
Kingston SV300S3, 60 Go | SSD des applications |
sdc |
Kingston SV300S3, 60 Go | SSD système (/) |
sdb, sdd |
WD Blue 2 To | données Storj |
sde |
disque 2,5" 1 To | Docker, données des services |
sdf |
disque 2,5" 1 To | inutilisé |
Première surprise, et première erreur de ma part : j’ai deux SSD identiques. Dans mes notes, je pensais que sda était le disque système. C’est faux, le système est sur sdc. Retenez ce détail, il va compter.
Étape 1 : sur quel disque écrit chaque conteneur ?
docker stats donne un total, tous disques confondus. Pour savoir où vont les écritures, il faut lire le fichier io.stat du cgroup du conteneur (cgroup v2). Il donne les octets écrits par disque physique.
J’ai écrit un petit script pour ça :
#!/bin/bash
# io-disques.sh NOM : écritures d'un conteneur par disque, depuis son démarrage
K=${1:?nom du conteneur}
ID=$(docker inspect -f '{{.Id}}' "$K") || exit 1
DEBUT=$(date -d "$(docker inspect -f '{{.State.StartedAt}}' "$K")" +%s)
S=$(( $(date +%s) - DEBUT ))
while read -r MAJMIN REST; do
W=$(grep -o 'wbytes=[0-9]*' <<<"$REST" | cut -d= -f2)
[ "${W:-0}" -lt 1000000 ] && continue
NOM=$(lsblk -dno NAME,MODEL "/dev/block/$MAJMIN" 2>/dev/null || echo "$MAJMIN")
awk -v w="$W" -v s="$S" -v k="$K" -v d="$NOM" 'BEGIN{printf "%-28s %-30s %7.2f Go (%.2f Go/jour)\n", k, d, w/1e9, w/1e9/s*86400}'
done < /sys/fs/cgroup/system.slice/docker-$ID.scope/io.stat
Résultat :
| Conteneur | SSD sda |
Disques durs |
|---|---|---|
| Nœud Storj n° 1 | 0,01 Go | 47,97 Go |
| Nœud Storj n° 2 | 0,01 Go | 47,78 Go |
| Ollama | 28,47 Go | 0 |
| Uptime Kuma | 0,64 Go | 0 |
| Serveur de jeu (PufferPanel) | 0,62 Go | 0,41 Go |
| Base PostgreSQL de Paperless | 0,30 Go | 0 |
| n8n | 0,13 Go | 0,04 Go |
Fausse piste n° 1 : Storj
Je pensais que Storj était le gros sujet : ses bases de données sont sur le SSD. En réalité, elles n’y ont écrit que 10 Mo par nœud. Les ~48 Go par nœud vont sur les WD Blue, exactement là où ils doivent aller. Non-sujet.
Fausse piste n° 2 : Ollama
28,47 Go sur le SSD, c’est beaucoup. Mais ollama list montre que j’avais téléchargé environ 35 Go de modèles pendant ces quelques jours. Ce sont des téléchargements ponctuels, pas une usure continue.
La preuve est venue deux jours plus tard : sur 34 heures sans nouveau téléchargement, le compteur d’Ollama n’a pas bougé d’un octet (30,96 Go avant, 30,96 Go après).
Leçon au passage : le script affiche « 6,91 Go/jour » pour Ollama. C’est une moyenne sur 4 jours, gonflée par deux téléchargements. Un débit moyen ne dit rien d’une écriture ponctuelle.
Le vrai problème : l’autre SSD
Pour avoir une vue d’ensemble, j’ai regardé ce que le noyau a écrit sur chaque SSD depuis le démarrage du serveur. Le 7e champ de /sys/block/<disque>/stat donne le nombre de secteurs de 512 octets écrits :
uptime -s
for d in sda sdc; do awk -v d=$d '{printf "%s : %.2f Go écrits depuis le démarrage\n", d, $7*512/1e9}' /sys/block/$d/stat; done
Sur 4,86 jours :
| SSD | Écrit depuis le démarrage | Par jour |
|---|---|---|
sda (applications) |
48,55 Go | ~10 Go |
sdc (système) |
67,75 Go | ~14 Go |
Le SSD système, sur lequel aucun conteneur n’écrit, recevait plus que celui des applications. J’ai donc regardé son SMART :
sudo smartctl -A /dev/sdc
5 Retired_Block_Count ... 0
9 Power_On_Hours_and_Msec ... 65104h+46m+52.450s
187 Reported_Uncorrect ... 1
231 SSD_Life_Left ... 001 001 011 ... FAILING_NOW 1
233 SandForce_Internal ... 48647
241 Lifetime_Writes_GiB ... 0
- SSD_Life_Left à 1 %, sous le seuil de 11 : smartctl le marque
FAILING_NOW. - 65 104 heures sous tension, soit environ 7 ans et demi.
- 48 647 Gio écrits en interne, environ 800 fois sa capacité.
- Déjà une erreur non corrigée.
- Le compteur 241 (écritures de l’hôte) est à 0 : il ne fonctionne pas sur ce disque.
Pour comparer, son jumeau sda, presque du même âge (61 130 heures), affiche 95 % de vie restante et 9 059 Gio écrits en interne.
Je cherchais qui usait le SSD des applications. Celui qui était en train de mourir, c’était l’autre.
Première chose faite : une sauvegarde complète du système sur un disque dur, puis une sauvegarde automatique chaque nuit (voir plus bas).
Trois nouvelles fausses pistes
Il fallait trouver ce qui écrivait ~14 Go par jour sur le disque système.
Fausse piste n° 3 : les journaux Docker
Je pensais que les journaux Docker n’avaient pas de limite. En fait, /etc/docker/daemon.json en avait déjà une (3 fichiers de 10 Mo), et Docker était installé sur un disque dur. Rien à voir avec sdc.
Fausse piste n° 4 : le swap
Mon suspect suivant : Ubuntu crée un fichier d’échange sur /, et Ollama consomme beaucoup de mémoire. Sauf que :
Swap: 0B 0B 0B
Pas de swap du tout.
Fausse piste n° 5 : systemd, 130 Go
J’ai ensuite listé les processus qui avaient le plus écrit, avec /proc/<PID>/io :
130.53 Go PID 1 /usr/lib/systemd/systemd --system
47.27 Go PID ... storagenode
47.02 Go PID ... storagenode
28.47 Go PID ... ollama serve
Le PID 1 aurait écrit 130 Go ? Non. Quand un processus se termine, Linux ajoute ses compteurs d’écriture à ceux du processus qui le « ramasse ». Et c’est systemd qui ramasse tous les services arrêtés et les processus orphelins. Ses 130 Go sont la somme de tout ce qui a écrit puis s’est arrêté depuis le démarrage, sur tous les disques. Un artefact de comptage, pas un coupable.
Le vrai coupable, trouvé avec fatrace
fatrace affiche en direct chaque fichier modifié. Avec l’option -c, lancée depuis /, il ne surveille que le système de fichiers racine. J’ai enregistré le résultat sur un disque dur, pour que la mesure ne s’observe pas elle-même :
sudo apt install -y fatrace
cd / && sudo timeout 600 fatrace -c -f W -o /chemin/vers/disque-dur/fatrace.txt
En 10 minutes :
== Processus
607 rsyslogd
290 containerd-shim
149 systemd-journal
== Fichiers
519 /var/log/syslog
148 /var/log/journal/.../system.journal
Ce sont les journaux système. Et sur Ubuntu, journald et rsyslog tournent en parallèle par défaut : chaque message est donc écrit deux fois.
Restait à savoir qui parlait autant. Sur les 5 000 dernières lignes du syslog, 4 154 venaient de systemd. Un coup d’œil suffit :
earnapp_upgrader.service: Scheduled restart job, restart counter is at 80521.
Started earnapp_upgrader.service - EarnApp auto-upgrader.
earnapp_upgrader.service: Main process exited, code=exited, status=203/EXEC
earnapp_upgrader.service: Failed with result 'exit-code'.
Un service de mise à jour d’EarnApp essayait de démarrer toutes les 5 secondes. Le code 203/EXEC signifie que le programme à lancer n’existe plus.
Quand je l’ai arrêté, le compteur en était à 80 537 redémarrages. À un essai toutes les 5 secondes, ça fait 4,66 jours : exactement depuis le démarrage du serveur. Quatre lignes de journal par essai, en double, jour et nuit.
C’est la même histoire que ma boucle de redémarrage SpiderFoot : un service qui plante en silence, et que personne ne regarde.
La correction
# Arrêter et désactiver le service fantôme
sudo systemctl disable --now earnapp_upgrader.service
sudo mv /etc/systemd/system/earnapp_upgrader.service ~/earnapp_upgrader.service.bak
sudo systemctl daemon-reload
# Arrêter le doublon : journald garde déjà tout (consultable avec journalctl)
sudo systemctl disable --now rsyslog
# Ne plus journaliser chaque paquet bloqué par le pare-feu
sudo ufw logging off
Les logs d’UFW étaient surtout remplis de paquets de diffusion envoyés par ma box, sans aucun intérêt.
Pour mesurer l’effet, j’enregistre un point de départ, puis je calcule le débit plus tard :
# Point de départ
for d in sda sdc; do echo "$(date +%s) $d $(awk '{print $7}' /sys/block/$d/stat)"; done >> ~/ecritures-ssd.log
# Plus tard : débit depuis le dernier point de départ
for d in sda sdc; do awk -v d=$d -v now=$(date +%s) -v w=$(awk '{print $7}' /sys/block/$d/stat) '$2==d{t=$1;s=$3} END{printf "%s : %.0f Mo en %.1f h (%.2f Go/jour)\n", d, (w-s)*512/1e6, (now-t)/3600, (w-s)*512/1e9/((now-t)/86400)}' ~/ecritures-ssd.log; done
Résultats sur sdc :
| Situation | Mesure | Débit |
|---|---|---|
| Moyenne depuis le démarrage | 4,86 jours | ~14 Go/jour |
| Avant correction | 121 Mo en 24 min | 7,31 Go/jour |
| EarnApp arrêté | 80 Mo en 94 min | 1,22 Go/jour |
| EarnApp + rsyslog + UFW, journée complète | 3 375 Mo en 33,9 h | 2,39 Go/jour |
Deux précisions honnêtes :
- La mesure « avant » ne dure que 24 minutes. Elle donne un ordre de grandeur, pas un chiffre précis.
- J’ai appliqué rsyslog et UFW avant la mesure de 34 h, donc je ne peux pas séparer leur effet de celui d’EarnApp. Le chiffre sur une journée entière (2,39) est plus élevé que celui sur 94 minutes (1,22), car la nuit apporte ses propres tâches : sauvegarde, mises à jour, statistiques.
Au total, on passe d’environ 14 à 2,4 Go par jour : près de 6 fois moins.
Le rebondissement : le SSD s’use tout seul
J’aurais pu m’arrêter là. Mais j’ai relevé le compteur interne (233) de sdc au début et à la fin de la mesure de 34 heures :
sdc |
Début | Fin (34 h plus tard) |
|---|---|---|
| Écrit par le système | +3,4 Go | |
| Écrit en interne (233) | 48 651 Gio | 48 698 Gio (+47 Gio) |
Le SSD a écrit en interne environ 14 fois ce que le système lui a envoyé.
Pour savoir si c’était normal, j’ai comparé avec son jumeau sda, sur 52 heures :
sda (sain) |
sdc (système) |
|
|---|---|---|
| Écrit en interne | +12 Gio | +51 Gio |
| Amplification | ≈ 2 | ≈ 13 à 14 |
Une amplification d’environ 2 est normale pour un SSD SandForce. 13 à 14, non. Le TRIM fonctionne pourtant bien (fstrim.timer est actif chaque semaine).
Mon hypothèse, que je ne peux pas prouver : en fin de vie, le contrôleur passe son temps à recopier ses propres données pour compenser l’usure des cellules. Ce qui veut dire que réduire les écritures ne le sauvera pas. Il s’use désormais en grande partie tout seul.
Ce que je fais en attendant le nouveau SSD
Je le remplace le mois prochain. D’ici là, une sauvegarde du système part chaque nuit sur un disque dur, avec une archive par jour de la semaine (7 jours d’historique) :
(sudo crontab -l 2>/dev/null; echo '0 4 * * * tar czf /chemin/vers/disque-dur/sauvegarde-systeme-$(date +\%u).tar.gz /etc /home/MOI /root /opt /usr/local /var/spool/cron 2>/dev/null') | sudo crontab -
(Les % doivent être échappés en \% dans une crontab.)
Si le SSD lâche demain, je perds au pire une journée.
J’avais pensé déplacer temporairement le système sur le disque 2,5" inutilisé. Son SMART m’en a vite dissuadé :
5 Reallocated_Sector_Ct ... 1408
197 Current_Pending_Sector ... 32
199 UDMA_CRC_Error_Count ... 13
1 408 secteurs déjà remplacés et 32 en attente : quitter un disque en fin de vie pour un autre qui se dégrade n’aurait servi à rien. Ça explique sans doute pourquoi il n’était utilisé par rien.
Deux pièges en chemin
Mon système est en français, et ça m’a joué deux tours :
sort -hlit « 5.12GB » comme « 5 ». Il fautLC_ALL=C sort.printfrefuse « 130.53 » : il attend une virgule. Même remède,export LC_ALL=Cavant la commande.
Ce que j’en retiens
- Mesurer par disque, pas au total.
docker statsm’aurait fait déplacer Storj pour rien. - Un débit moyen peut mentir. Un seul téléchargement de modèle suffit à fausser des Go/jour calculés sur quelques jours.
- Regarder le SMART de tous ses disques, même ceux qu’on croit tranquilles. Le mien était à 1 % et je ne le savais pas.
- Surveiller les services en échec. Un simple
systemctl --failedde temps en temps aurait montré EarnApp tout de suite. - Raconter ses fausses pistes. J’en ai suivi six, et chacune m’a appris quelque chose sur la façon dont Linux compte les écritures.
Prochain article :