Uptime Kuma, c’est l’outil qui vérifie en permanence que mes services répondent. Il est léger, joli, et il m’envoie une alerte quand Vaultwarden ou Paperless tombe. Je l’avais installé en deux minutes et je n’y pensais plus.
Puis j’ai regardé combien chaque conteneur écrivait sur le disque. Uptime Kuma avait écrit 5,12 Go en 90 heures. Sa base de données, elle, pèse 21 Mo. Il a donc écrit 240 fois plus que ce qu’il garde.
Et je n’avais rien bricolé : 27 sondes, toutes à l’intervalle par défaut de 60 secondes.
Pourquoi ça m’inquiète
Le système et Docker tournent sur un SSD de 60 Go récupéré, qui a déjà vécu avant d’arriver chez moi. Un SSD a une endurance limitée : chaque cellule supporte un nombre fini d’écritures, et les petits modèles d’entrée de gamme sont les premiers à s’user.
1,36 Go par jour, c’est environ 500 Go par an pour un seul service. Et ce n’est que ce que le système envoie : le SSD, lui, en écrit encore un peu plus en interne (on le verra plus bas).
Mesurer ce qu’écrit un conteneur
Repérer le coupable avec docker stats
La colonne BLOCK I/O donne le total lu et écrit par chaque conteneur depuis son dernier démarrage. Pour classer les conteneurs selon ce qu’ils écrivent :
docker stats --no-stream --format "table {{.Name}}\t{{.BlockIO}}" | LC_ALL=C sort -k4 -h | tail -6
Le LC_ALL=C n’est pas là pour décorer. Sur un système en français, sort attend une virgule décimale : il lit « 5.12GB » comme « 5 » et range le pire conteneur tout en bas du classement. C’est exactement ce qui m’est arrivé au premier essai.
Chez moi, Uptime Kuma sortait avec 91.7MB / 5.12GB : 92 Mo lus, 5,12 Go écrits.
Calculer un débit par jour
Le compteur repart de zéro à chaque redémarrage du conteneur. Pour obtenir un chiffre comparable, on le divise par le temps écoulé depuis le démarrage. Le compteur le plus fiable est celui du cgroup du conteneur, que Docker lit lui-même. Celui du PID 1 affiche souvent zéro, car c’est un processus enfant qui écrit vraiment.
J’ai mis le calcul dans un petit script :
cat > ~/conteneur-io.sh <<'EOF'
#!/bin/bash
# Usage : ~/conteneur-io.sh nom-du-conteneur
K=${1:?nom du conteneur}
ID=$(docker inspect -f '{{.Id}}' "$K") || exit 1
DEBUT=$(date -d "$(docker inspect -f '{{.State.StartedAt}}' "$K")" +%s)
W=$(awk '{for(i=2;i<=NF;i++) if($i ~ /^wbytes=/){sub("wbytes=","",$i); s+=$i}} END{print s+0}' \
/sys/fs/cgroup/system.slice/docker-$ID.scope/io.stat)
S=$(( $(date +%s) - DEBUT ))
awk -v w="$W" -v s="$S" -v k="$K" 'BEGIN{printf "%s : %.2f Go écrits en %.1f h, soit %.2f Go/jour\n", k, w/1e9, s/3600, w/1e9/s*86400}'
EOF
chmod +x ~/conteneur-io.sh
~/conteneur-io.sh uptime-kuma-uptime-kuma-1
Le chemin /sys/fs/cgroup/system.slice/ correspond à un système récent (cgroup v2 avec systemd), ce qui est le cas sur Debian 12 et Ubuntu 22.04 ou plus.
Vérifier l’usure du SSD
Le SSD garde son propre total d’écritures dans ses données SMART :
sudo smartctl -A /dev/sda | grep -iE "writ|241|233"
Le nom des attributs change selon le fabricant. Sur mon Kingston à contrôleur SandForce, ça donne :
233 SandForce_Internal ... 9053
241 Lifetime_Writes_GiB ... 6153
L’attribut 241 compte ce que le système a envoyé (6 153 Gio sur toute la vie du disque). Le 233 compte ce que le SSD a réellement écrit dans ses cellules (9 053 Gio). Le rapport entre les deux, 1,47, c’est l’amplification d’écriture : chaque Go qu’envoie Uptime Kuma use en réalité près d’un Go et demi de cellules.
Pourquoi Uptime Kuma écrit autant
Chaque vérification, que l’outil appelle heartbeat, est enregistrée comme une ligne dans sa base SQLite. Chez moi : 147 439 lignes en un peu moins de quatre jours, ce qui correspond pile à 27 sondes × 1 440 vérifications par jour.
Une ligne, c’est quelques centaines d’octets. Mais SQLite ne peut pas écrire juste ces octets-là. Pour ne rien perdre en cas de coupure, il écrit d’abord les pages modifiées (4 Ko chacune) dans un journal, met à jour les index (encore des pages), force l’écriture sur le disque, puis recopie le tout dans la base principale. En divisant 5,12 Go par le nombre de vérifications, on tombe sur environ 35 Ko écrits par vérification.
Le nombre de vérifications est donc le seul levier qui compte vraiment :
| Intervalle | Vérifications par jour pour 27 sondes |
|---|---|
| 60 s (défaut) | 38 880 |
| 120 s | 19 440 |
| 300 s | 7 776 |
Il y a aussi l’historique. Par défaut, Uptime Kuma garde 180 jours de résultats. À ce rythme, la base aurait fini autour de 1 Go, avec des nettoyages et des recalculs de statistiques de plus en plus lourds.
Avant de toucher à quoi que ce soit : la sauvegarde
Il suffit de copier le dossier data du conteneur arrêté. Pour retrouver son chemin :
docker inspect -f '{{range .Mounts}}{{.Source}} -> {{.Destination}}{{"\n"}}{{end}}' uptime-kuma-uptime-kuma-1
Puis :
docker stop uptime-kuma-uptime-kuma-1
sudo cp -a /chemin/vers/uptime-kuma/data ~/sauvegarde-uptime-kuma-$(date +%F)
docker start uptime-kuma-uptime-kuma-1
ls -lh ~/sauvegarde-uptime-kuma-*/
Le kuma.db de la sauvegarde doit avoir la même taille que l’original. Et un conseil tiré de l’expérience : gardez la commande de restauration dans un coin, mais ne la collez pas dans le même bloc que le reste. Je l’ai fait, et j’ai annulé mes réglages trente secondes après les avoir appliqués.
Réglage n° 1 : espacer les vérifications
Toutes mes sondes n’ont pas besoin de la même attention. J’ai fait trois groupes :
- 60 s pour 7 sondes : Vaultwarden, Paperless (serveur web et base), Gitea, n8n et mes deux nœuds Storj. Pour Storj, une panne qui dure fait baisser la note de disponibilité du nœud, donc je veux la voir vite.
- 300 s pour les 19 autres : IT-Tools, Excalidraw, Stirling-PDF, SearXNG… Savoir qu’un convertisseur de PDF est tombé il y a cinq minutes plutôt qu’une, ça ne change rien.
- Une sonde désactivée : celle qui surveillait Uptime Kuma lui-même. S’il tombe, il ne peut prévenir personne.
Pour toutes, la nouvelle tentative passe à 60 s (elle ne sert que pour confirmer une panne) et le nombre de tentatives à 2, pour éviter les fausses alertes.
Résultat sur le papier : 7 × 1 440 + 19 × 288 = 15 552 vérifications par jour, au lieu de 38 880. C’est 60 % de moins.
Modifier toutes les sondes d’un coup
Ça se fait dans l’interface, sonde par sonde (Modifier, puis Intervalle de vérification). Avec 27 sondes, j’ai préféré passer directement par la base SQLite, conteneur arrêté et sauvegarde faite.
On liste d’abord les sondes pour noter les numéros à garder à 60 s :
sudo python3 - <<'EOF'
import sqlite3
c = sqlite3.connect("file:/chemin/vers/uptime-kuma/data/kuma.db?mode=ro", uri=True)
for r in c.execute("select id, name, interval from monitor where active=1 order by name"):
print(r)
EOF
Puis on applique les nouveaux intervalles (remplacez les numéros par les vôtres) :
docker stop uptime-kuma-uptime-kuma-1
sudo python3 - <<'EOF'
import sqlite3
db = sqlite3.connect("/chemin/vers/uptime-kuma/data/kuma.db")
garder = (1, 2, 3, 17, 20, 21, 25) # sondes qui restent à 60 s
with db:
db.execute("update monitor set interval=300, retry_interval=60, maxretries=2 where active=1")
db.execute(f"update monitor set interval=60 where id in {garder}")
for r in db.execute("select interval, count(*) from monitor where active=1 group by interval"):
print(f"{r[1]} sondes à {r[0]} s")
db.close()
EOF
docker start uptime-kuma-uptime-kuma-1
Testé sur la version 1 d’Uptime Kuma. Les noms de colonnes peuvent changer d’une version à l’autre : en cas de doute, passez par l’interface.
Réglage n° 2 : 14 jours d’historique
Dans Paramètres, section Historique des sondes (Monitor History), je garde 14 jours au lieu de 180. C’est largement assez pour comprendre une panne récente.
Sur la même page, un bouton supprime l’ancien historique tout de suite, et un autre réduit la taille de la base SQLite (Shrink Database) pour récupérer la place libérée.
Le résultat
Mesure prise avec le script ci-dessus, 23,6 heures après les réglages :
uptime-kuma-uptime-kuma-1 : 0.64 Go écrits en 23.6 h, soit 0.65 Go/jour
| Avant | Après | |
|---|---|---|
| Sondes à 60 s / à 300 s | 27 / 0 | 7 / 19 |
| Vérifications par jour | 38 880 | 15 552 |
| Écritures par jour | 1,36 Go | 0,65 Go |
| Écritures par an | ~500 Go | ~240 Go |
| Historique conservé | 180 jours | 14 jours |
| Taille maximale de la base | ~1 Go | ~30 Mo |
Les écritures sont divisées par deux. C’est un peu moins que les 60 % prévus sur le papier : chaque vérification coûte maintenant environ 42 Ko au lieu de 35 Ko. Une partie des écritures ne dépend pas du nombre de vérifications (le démarrage du conteneur, la réduction de la base, les statistiques recalculées en arrière-plan), et elle pèse plus lourd quand il y a moins de vérifications pour l’amortir.
Côté taille, la base fait toujours 20 Mo aujourd’hui, car elle n’avait que quatre jours d’historique. Le vrai gain, c’est le plafond : avec 14 jours de 15 552 vérifications, elle ne dépassera pas une trentaine de Mo, là où elle aurait fini autour de 1 Go.
Le tout sans rien perdre d’utile : les services importants sont toujours vérifiés chaque minute.
Et si ça ne suffit pas
Deux pistes que je garde sous le coude :
- Passer à la version 2. J’utilise encore l’image
louislam/uptime-kuma:1. La version 2, sortie en octobre 2025, stocke les résultats sous une forme agrégée et gère mieux les grosses bases. La migration de la base prend quelques minutes au premier démarrage, et je voulais d’abord mesurer l’effet des réglages ci-dessus sans tout mélanger. Ce sera l’objet d’une prochaine mesure. - Sortir la base du SSD. Déplacer le dossier
datasur un disque dur supprime le problème d’usure. Pour un outil comme celui-ci, la différence de vitesse ne se verrait pas.
À retenir
- Un outil de supervision écrit en permanence, même quand tout va bien, et même avec les réglages par défaut.
- Ce qui compte n’est pas la taille de la base, mais le nombre d’écritures : 21 Mo stockés, 5 Go écrits.
- Espacer les vérifications des services secondaires et raccourcir l’historique a divisé les écritures par deux, en dix minutes de réglages.
docker stats(avecLC_ALL=C) suffit pour repérer le conteneur qui écrit le plus. Lancez-le chez vous.
En faisant ces mesures, j’ai vu passer d’autres chiffres étonnants : Ollama et mes nœuds Storj ont écrit des dizaines de Go en quelques jours. La semaine prochaine, je regarde où vont ces écritures, et lesquelles tombent vraiment sur le SSD.