Aller au contenu

Diagnostic d'activité disque - Podman et services systemd

De Loic Wiki
Version datée du 19 octobre 2026 à 21:05 par Admin (discussion | contributions) (Déroulement de l'enquête disque : commandes/options, preuves, essais expirés et limites)
(diff) ← Version précédente | Version actuelle (diff) | Version suivante → (diff)

Diagnostic d’activité disque - Podman et services systemd

Objectif, périmètre et précautions

Comprendre quel travail produit les entrées/sorties (E/S), qui le réalise, où les octets sont stockés et pourquoi les applications attendent. Une LED de disque allumée ou une charge élevée n’identifie ni une application ni une panne.

Cette procédure vise Linux, Podman rootless et systemd utilisateur. Les principes restent valables pour des services système, mais leur gestionnaire, leurs permissions et leurs emplacements sont distincts. Les commandes s’exécutent sur l’hôte, avec le compte propriétaire des conteneurs. Ne pas remplacer arbitrairement podman par sudo podman : on interrogerait un autre stockage et un autre ensemble de conteneurs.

Les exemples emploient des noms fictifs et ne publient ni secrets, ni adresses, ni inventaire des chemins de données du serveur. Remplacer les valeurs mon-conteneur, mon-service.service et les noms de disques par ceux découverts localement. $HOME désigne le domicile du compte ; %h est une notation systemd, pas une variable du shell.

Sécurité : cette procédure est une collecte en lecture seule, hors fichiers de rapport éventuels. Aucun arrêt, redémarrage, vidage de caches, nettoyage d’images, suppression de volumes ou test de charge n’est nécessaire pour commencer. Ne jamais désactiver fsync ou la durabilité d’une base pour masquer une latence. Éviter du récursif, find /, les scans complets et les captures non bornées pendant l’incident : le diagnostic peut lui-même charger le disque.

Les commandes détaillées ci-dessous constituent une procédure réutilisable ; elles ne sont pas toutes présentées comme ayant été exécutées lors du cas historique. La section datée distingue les observations de l’incident des vérifications de métadonnées ultérieures.

1. La chaîne causale : déclencheur, travail, processus, stockage

Déclencheur : démarrage, timer, requête, import, reprise après incident
        |
        v
Service systemd / lanceur Compose / tâche interne de l'application
        |
        v
Conteneur applicatif ------ requêtes SQL ------> conteneur de base
        |                                           |
        v                                           v
Processus hôte + cgroup                         processus PostgreSQL
        |                                           |
        +------ écritures de fichiers / WAL / journaux
                            |
                            v
       volume nommé / bind mount / couche inscriptible / journald
                            |
                            v
       système de fichiers hôte -> couche bloc -> support physique

Un conteneur n’est pas une machine avec son propre disque : ses processus utilisent le noyau de l’hôte. Les espaces de noms changent la visibilité des PID, utilisateurs et montages ; les cgroups regroupent et comptabilisent des ressources. Le processus qui écrit n’est pas toujours celui qui décide du travail. Une application peut demander un import SQL à une base située dans un autre conteneur : la base apparaît comme écrivain, l’importeur reste l’origine fonctionnelle.

Il faut donc établir deux rapprochements indépendants :

  1. Processus -> conteneur/service : PID hôte, liste des processus, cgroup, unité ou labels du lanceur.
  2. Fichier/volume -> système de fichiers -> disque : montages du conteneur, source hôte, findmnt, puis lsblk.

L’activité réseau peut déclencher des écritures, mais elle n’est pas elle-même une E/S bloc. Le téléchargement d’un flux peut aussi être terminé alors que sa décompression, son import et ses index continuent longtemps.

2. Distinguer débit, latence, file, occupation et pression

Indicateur Ce qu’il mesure Ce qu’il ne prouve pas
rMB/s, wMB/s d’iostat Débit lu/écrit pendant l’intervalle ; avec -m, unités binaires MiB/s malgré le libellé MB Bande passante maximale du support, identité de l’application
r/s, w/s Requêtes bloc par seconde, après fusions Nombre de requêtes SQL ou nombre de fichiers
r_await, w_await Durée moyenne en ms, attente en file et traitement compris Latence pure du composant matériel, pire latence d’une requête
aqu-sz Nombre moyen de requêtes en cours Nombre de processus bloqués
%util Temps comptabilisé avec E/S en cours Pourcentage d’espace utilisé ; plafond universel d’un SSD/NVMe
CPU wa / %iowait Temps CPU inactif alors qu’une E/S disque est en attente Pourcentage d’utilisation du disque ; part attribuable à une application
vmstat b, état D Tâches bloquées / attente non interruptible Preuve automatique de panne ; toute attente D n’est pas un disque local
df Occupation du système de fichiers Débit ou activité à cet instant
podman stats BlockIO Compteurs d’octets E/S rapportés par les cgroups Débit instantané ; exhaustivité garantie sur chaque configuration

Débit modéré et forte gêne peuvent coexister. Beaucoup de petites écritures synchrones coûtent davantage de latence qu’un gros transfert séquentiel. Une base qui attend la durabilité du WAL peut ralentir avec un débit bien inférieur au débit commercial annoncé du SSD.

Une valeur isolée de %util, même voisine de 100 %, ne suffit pas. Recouper latences, files, débit, attente applicative et évolution dans le temps. Une valeur brute supérieure à 100 % doit être signalée comme anomalie de mesure/comptabilisation, pas normalisée silencieusement ni présentée comme une occupation physique exacte. Sur RAID, chiffrement ou LVM, plusieurs lignes bloc peuvent décrire les mêmes E/S : ne pas additionner partitions, volumes logiques et disque physique.

3. D’où viennent les E/S autour de Podman ?

Origine Mécanisme Indices à chercher
Base de données Tables, index, WAL, checkpoints, récupération, maintenance Backend SQL, walwriter/checkpointer, journaux d’import et de checkpoint
Application Uploads, OCR, miniatures, indexation, archives, caches Étape de travail dans les logs, PID écrivain, volume destination
Couche inscriptible Fichiers créés hors volumes ; avec overlay, certaines modifications entraînent un copy-up Mounts ne couvre pas la destination ; stockage graphroot et pilote à identifier
Images Téléchargement, décompression, extraction de couches, construction Processus Podman/build, journal de mise à jour, changement d’image
Journaux stdout/stderr, traces d’erreur répétées, logs applicatifs en fichiers Pilote de logs, fréquence des messages, emplacement journald ou fichier
Boucle de redémarrage Initialisation répétée, ouverture de base, caches recréés, erreurs répétées Évolution des compteurs, démarrages récents, même erreur répétée
Contrôle de santé Processus exécutés périodiquement dans un conteneur Configuration Healthcheck, fréquence, timers associés ; pas forcément un redémarrage
Sauvegarde / scan / synchronisation Lecture massive, compression, copie, antivirus ou scanner Unité et timer, processus, destination de copie
Noyau Écritures différées, journal du système de fichiers, swap Workers de writeback, état Dirty/Writeback, vmstat si/so, journaux noyau

Un volume nommé n’est pas forcément sur un disque dédié. Un chemin rapide à l’intérieur du conteneur ne dit rien du support réel. Les journaux journald ne résident pas nécessairement sur le même support que les données applicatives ; journald peut aussi être volatil en RAM selon sa configuration.

conmon est le moniteur du conteneur, pas le moteur SQL. Un worker flush-* réalise du writeback ; un thread jbd2 participe au journal ext4. Les voir actifs n’identifie pas à lui seul l’application initiale. Le modèle exact dépend du pilote de stockage et du système de fichiers ; ne pas supposer overlay ou ext4 sans vérification.

4. Collecter une fenêtre courte et datée

4.1 Inventaire et disponibilité des outils

date --iso-8601=seconds
uptime
command -v iostat pidstat vmstat podman
lsblk -e 7 -o NAME,MAJ:MIN,MODEL,TRAN,ROTA,SIZE,TYPE,FSTYPE,MOUNTPOINTS
df -hT -x tmpfs -x devtmpfs -x squashfs
free -h
  • date --iso-8601=seconds : horodatage avec décalage de fuseau, indispensable pour rapprocher des journaux.
  • uptime : charge sur une, cinq et quinze minutes. La charge compte aussi des tâches en attente non interruptible : ce n’est pas un pourcentage CPU.
  • command -v : disponibilité dans le PATH, sans installation ni exécution des outils. Un outil absent reste une limite explicite.
  • lsblk -e 7 : exclut le majeur des loop devices ; -o choisit les colonnes. MAJ:MIN relie périphériques et cgroups ; ROTA indique le caractère rotatif ; TRAN le transport. Les noms sda peuvent changer entre démarrages.
  • df -hT : taille lisible et type ; chaque -x exclut un type. Un montage d’image en lecture seule à 100 % n’est pas automatiquement un problème d’espace.
  • free -h : privilégier la mémoire disponible. Une swap occupée peut être ancienne ; vérifier le trafic si/so avant d’accuser la pagination.

4.2 Mesurer maintenant, pas depuis le démarrage

Après avoir adapté les noms des disques :

LC_ALL=C iostat -x -y -m sda sdb nvme0n1 2 5
LC_ALL=C vmstat -w 2 3
LC_ALL=C pidstat -d -p ALL 2 5
ps -eo pid,ppid,uid,stat,wchan:32,comm --sort=stat
  • LC_ALL=C : langue et séparateurs stables pour cette commande seulement.
  • iostat -x : détails ; -y : omet le premier rapport depuis le démarrage ; -m : MiB/s ; 2 5 : cinq rapports espacés de deux secondes. Retirer la liste des disques pour un premier inventaire si nécessaire.
  • vmstat -w : affichage large ; 2 3 : trois rapports espacés de deux secondes. Le premier contient notamment des moyennes depuis le démarrage : les suivants caractérisent l’activité courante. Examiner b, si, so, wa ensemble.
  • pidstat -d : E/S par tâche ; -p ALL : tous les processus ; 2 5 : intervalle et nombre. Un refus de lecture ou une valeur indisponible ne vaut pas zéro E/S.
  • ps -e : tous les processus ; -o : colonnes ; wchan:32 : fonction d’attente et largeur ; --sort=stat : tri par état. comm limite les risques de divulgation comparé aux arguments complets. Ne publier des lignes de commande qu’après suppression des secrets.

Ces commandes lancées successivement décrivent des fenêtres différentes. Pour comparer des débits exactement, lancer les mesures en parallèle et conserver début, fin et intervalle. Ne pas présenter deux captures espacées de plusieurs minutes comme une ventilation du même trafic.

5. Relier les processus aux conteneurs

5.1 Identité, PID hôte et espace de noms

podman ps -a --no-trunc --format '{{.ID}} {{.Names}} {{.Status}}'
C='mon-conteneur'
timeout 15s podman inspect --format '{{.Name}} pid={{.State.Pid}} state={{.State.Status}} restarts={{.RestartCount}} started={{.State.StartedAt}}' "$C"
podman top "$C" hpid,pid,user,comm
  • ps -a : conteneurs arrêtés compris ; --no-trunc : identifiants complets, utiles pour les cgroups ; --format : extrait uniquement les informations nécessaires.
  • inspect lit les métadonnées sans lancer de commande dans le conteneur. State.Pid est le PID principal vu de l’hôte, pas tous les workers. Pour un conteneur arrêté, ce PID n’est pas une cible d’observation valide.
  • podman top donne ici hpid (PID hôte), pid (PID interne), utilisateur et nom du processus. Un PostgreSQL PID 1 dans son conteneur peut avoir un tout autre PID hôte. Les descripteurs de top peuvent varier selon la version ; consulter son aide locale si nécessaire.
  • timeout 15s borne l’attente du client de diagnostic. Le code 124 indique généralement une expiration, pas l’arrêt du service. Une limite de durée ne garantit pas un retour instantané si un processus est lui-même bloqué en attente noyau.

Éviter l’inspection JSON intégrale dans un rapport partagé : elle peut exposer mots de passe, jetons, chemins et arguments sensibles.

5.2 Lire les compteurs rootless sans devenir root de l’hôte

Quand pidstat ne peut pas lire les UID mappés des conteneurs :

timeout 8s podman unshare true
timeout 30s podman unshare pidstat -d -p ALL 2 5

podman unshare exécute la commande dans l’espace de noms utilisateur rootless. Ce n’est ni sudo, ni podman exec : on n’entre pas dans le système de fichiers applicatif du conteneur. true vérifie seulement que cette entrée fonctionne. L’accès dépend toujours des politiques de sécurité, du montage de /proc et des permissions ; le compte n’obtient pas un accès universel à tous les processus de l’hôte.

Pour réduire la collecte, remplacer ALL par la liste de PID hôte découverte avec podman top, séparés par des virgules. Ne pas réutiliser les PID du cas historique. Pour une sonde personnalisée, vérifier /proc/PID/stat et son champ starttime avant/après : un PID peut être réutilisé.

5.3 Ce que signifient les octets attribués

Dans /proc/PID/io, rchar/wchar décrivent les octets des appels de lecture/écriture, pas le trafic physique. read_bytes/write_bytes se rapprochent du stockage ; ils restent soumis au cache, aux écritures annulées et à la comptabilité du noyau. Les statistiques incluent aussi des enfants attendus selon l’interface : ne pas additionner aveuglément un parent et ses enfants. Les processus nés et morts entre deux instantanés peuvent échapper à un collecteur.

La règle de mesure est une différence de compteurs divisée par une durée effectivement mesurée. Pour exprimer un débit en MiB/s, diviser les octets par la durée en secondes puis par 1 048 576. Ne pas utiliser le total depuis le démarrage comme s’il s’agissait d’un débit actuel.

6. Contrôler les cgroups sans double comptage

podman info --format 'cgroup={{.Host.CgroupsVersion}}'
podman stats --no-stream --format '{{.Name}} {{.BlockIO}}' "$C"
PID=$(podman inspect --format '{{.State.Pid}}' "$C")
python3 -c 'import pathlib,sys; print((pathlib.Path("/proc")/sys.argv[1]/"cgroup").read_text())' "$PID"

--no-stream demande une seule capture de stats ; BlockIO est un cumul rapporté, pas une vitesse. 0B / 0B n’est pas une preuve suffisante d’inactivité, surtout si d’autres mesures montrent des écritures. Une valeur manquante ou des limites de comptabilité peuvent rendre l’attribution incomplète. Cgroup v1 rootless n’offre pas le même support que v2 ; ce guide vise v2.

En cgroup v2, /proc/PID/cgroup contient normalement une entrée 0::/chemin. Le fichier io.stat du groupe correspondant se trouve sous /sys/fs/cgroup/chemin/. Lire deux fois ce fichier à intervalle connu permet de comparer rbytes, wbytes, rios, wios par MAJ:MIN ; lsblk permet le rapprochement. Lire seulement le groupe du PID principal peut manquer d’autres groupes de la même unité : vérifier la hiérarchie avant d’attribuer un total.

Ne pas sommer tous les fichiers io.stat trouvés. Parents et descendants peuvent couvrir le même travail ; choisir un niveau de regroupement non recouvrant. La délégation, les sous-groupes et les capacités du système de fichiers influencent le writeback attribuable. Les journaux écrits par journald peuvent être comptés hors du groupe de l’application. Les cgroups servent à confirmer une attribution, pas à fabriquer un total qui ne correspond pas aux E/S bloc observées.

7. Déterminer sur quel disque les écritures arrivent

podman inspect --format '{{json .Mounts}}' "$C"
podman info --format 'graphroot={{.Store.GraphRoot}}'

Pour chaque montage, relever Type, Source hôte, Destination conteneur, RW et le nom de volume éventuel. Ensuite, remplacer le chemin d’exemple par la Source réellement lue :

findmnt -T '/chemin/source/hote' -o SOURCE,TARGET,FSTYPE
lsblk -e 7 -o NAME,MAJ:MIN,PKNAME,TYPE,FSTYPE,MOUNTPOINTS
  • findmnt -T : système de fichiers qui contient le chemin ; -o : colonnes explicites. lsblk rattache une partition ou un volume logique à sa hiérarchie de périphériques.
  • Un bind mount pointe vers un chemin hôte choisi ; un volume nommé est géré par Podman et peut avoir son propre pilote ou montage. Ne pas deviner sa localisation à partir de son nom.
  • Une destination non couverte par un volume peut écrire dans la couche inscriptible du conteneur. Le graphroot aide à localiser le stockage des images/couches, sans prouver que toute E/S du conteneur y aboutit.
  • Plusieurs services peuvent partager le même système de fichiers : base, images et journaux se concurrencent alors sur le même support.
  • Sur NFS, tmpfs, stockage chiffré ou RAID, poursuivre l’analyse au bon niveau ; findmnt seul ne donne pas toujours un disque physique local unique.

8. Relier le conteneur au service et au déclencheur

8.1 Identifier le superviseur réel

podman inspect --format '{{index .Config.Labels "PODMAN_SYSTEMD_UNIT"}}' "$C"
podman inspect --format '{{json .HostConfig.RestartPolicy}}' "$C"
U='mon-service.service'
systemctl --user show "$U" -p FragmentPath -p SourcePath -p ActiveState -p SubState -p Restart -p NRestarts -p WantedBy -p RequiredBy -p ControlGroup
systemctl --user list-dependencies --reverse --all "$U" --no-pager

Le label PODMAN_SYSTEMD_UNIT, lorsqu’il existe, est un indice du lanceur : le confirmer avec l’unité et le cgroup, pas seulement avec le nom du conteneur. Il peut désigner un service de stack Compose plutôt qu’une unité par conteneur. Son absence ne prouve pas l’absence de supervision systemd.

systemctl --user interroge le gestionnaire de l’utilisateur ; sans --user, on interroge le gestionnaire système. show -p demande des propriétés précises : FragmentPath pour l’unité chargée, SourcePath pour sa source éventuelle, ControlGroup pour le regroupement. Une unité generated indique souvent un fichier produit par un générateur : modifier sa source persistante, pas le fichier sous /run.

Restart= de systemd et la politique de redémarrage Podman sont deux mécanismes différents. NRestarts et RestartCount ne sont pas interchangeables et peuvent être remis à zéro par une recréation. Un total élevé ne suffit pas à dater une boucle. Observer son évolution et des événements de démarrage horodatés.

8.2 Chercher qui déclenche le travail

systemctl --user list-timers --all --no-pager
systemctl list-timers --all --no-pager
journalctl --user -u "$U" --since '-2 hours' -n 80 --no-pager -o short-iso

list-timers --all montre aussi des minuteurs inactifs ; NEXT, LAST et ACTIVATES orientent vers le service exécuté. Le gestionnaire système peut être lisible sans privilèges, mais la visibilité dépend des droits. journalctl --user -u filtre l’unité utilisateur ; --since borne la période ; -n limite les entrées ; -o short-iso conserve un horodatage lisible avec fuseau ; --no-pager produit une sortie directe.

Un timer Podman associé à un identifiant de conteneur peut piloter un healthcheck, pas une mise à jour. Lire l’unité cible et sa commande avant de conclure. Un healthcheck en échec ne redémarre le conteneur que si une politique le prévoit. Une tâche interne, une requête ou un import au démarrage peut produire des E/S sans timer systemd.

LAST proche de l’incident est une corrélation. Pour établir la causalité, lire le journal du service lancé, puis celui de l’application qui importe ou reconstruit ses données.

8.3 Démarrage automatique, redémarrage et arrêt ne sont pas synonymes

Pour Quadlet, l’automatisation peut provenir de [Install] WantedBy=default.target dans le fichier .container. Le générateur applique cette section au démarrage du gestionnaire utilisateur et lors de daemon-reload. Un systemctl disable classique n’est pas la bonne recette générale pour une unité générée.

Désactiver ce rattachement n’arrête pas une instance en cours, n’empêche pas un démarrage manuel et ne bloque pas forcément une activation par dépendance, timer ou socket. Inversement, arrêter un service ne supprime pas son démarrage automatique. Restart=on-failure définit une reprise après échec, pas à lui seul un lancement à la prochaine session. Avec le linger, un gestionnaire utilisateur peut démarrer au boot sans ouverture de session interactive. Toute modification demande une décision explicite et une vérification des autres déclencheurs.

9. Lire les journaux au bon endroit

podman inspect --format '{{.HostConfig.LogConfig.Type}}' "$C"
timeout 15s podman logs --since 15m --tail 60 "$C"

LogConfig.Type indique le pilote ; logs --since 15m --tail 60 limite ancienneté et volume. Les logs peuvent contenir des secrets ou des données métier : ne publier que des extraits assainis.

Si le pilote est journald, une lecture directe évite de dépendre du client Podman :

timeout 15s journalctl "CONTAINER_NAME=$C" --since '-30 minutes' -n 60 --no-pager -o short-iso
journalctl "CONTAINER_NAME=$C" --since '-2 hours' --grep='checkpoint|Updating|COPY|recovery|ERROR' -n 40 --no-pager -o short-iso
journalctl -k -b -p warning --since '-30 minutes' -n 60 --no-pager
journalctl -t systemd-coredump --since '-30 minutes' -n 20 --no-pager
  • CONTAINER_NAME=... : filtre sur un champ structuré. Vérifier le nom exact et les permissions ; une absence de résultat peut signifier mauvais pilote, mauvaise fenêtre ou manque de visibilité.
  • --grep : expression régulière sur les messages, ici un filtre d’exemple à adapter ; il peut masquer une erreur rédigée autrement. Lire aussi un petit extrait non filtré.
  • -k -b : noyau du boot courant ; -p warning : avertissements et niveaux plus graves.
  • -t systemd-coredump : identifiant de journal du gestionnaire de dumps. Les dumps peuvent eux-mêmes être volumineux ; ne pas les supprimer avant d’avoir compris l’émetteur.
  • -o cat, parfois utile pour isoler un message, retire le préfixe d’horodatage de journald : ne pas perdre la chronologie lorsqu’une application ne date pas ses propres lignes.

Comparer des heures dans le même fuseau. Le 18 octobre 2026, les observations du rapport ont été notées en UTC et en heure de Paris, UTC+02:00. Cette correspondance ne doit pas être réutilisée aveuglément à une autre saison.

10. Pourquoi PostgreSQL écrit après une requête ou un import

Un import peut produire plusieurs flux :

  1. Le backend SQL reçoit les données, par exemple via COPY, et modifie les pages de tables et d’index en mémoire.
  2. Le WAL conserve les informations nécessaires à la récupération. Des écritures peuvent provenir du walwriter et des backends ; leurs synchronisations participent à la durabilité selon la configuration.
  3. Le background writer et les backends écrivent des pages modifiées ; le checkpointer organise les checkpoints.
  4. Le cache du noyau et le système de fichiers peuvent différer l’écriture effective. Des synchronisations imposent ensuite de rendre les données durables.

Ainsi, l’importeur, le backend SQL, le walwriter, le checkpointer et le writeback noyau décrivent différentes parties du même travail. Les additionner comme des causes indépendantes serait trompeur. Des octets de WAL et des octets de tables sont bien des écritures distinctes, mais les métriques de processus, cgroups et disques ne sont pas des étages indépendants à sommer.

Le manuel PostgreSQL précise : « The checkpoint requirement of flushing all dirty data pages to disk can cause a significant I/O load ». Il précise aussi que les écritures des checkpoints sont étalées volontairement. Donc un checkpoint long ne signifie pas, à lui seul, un disque lent : examiner séparément write, sync, les latences bloc et la progression de l’application. Une longue phase sync recoupée avec des attentes bloc est un indice plus précis de pression de synchronisation.

Ce guide explique le mécanisme, pas les réglages de performance à appliquer sans étude. Modifier max_wal_size, les checkpoints ou la durabilité peut déplacer le problème et changer le temps de récupération ; sauvegarde, version de PostgreSQL, charge et capacité du support doivent être examinées avant toute décision.

11. Cas documenté du 18 octobre 2026 : Greenbone et anomalie Dify

11.1 Fenêtre historique, environ 17 h 06 à 17 h 31, heure de Paris

Le rapport local conservé de cet incident a identifié un import des vulnérabilités Greenbone dans PostgreSQL comme principale origine étayée de la pression d’écriture. Les noms d’hôte, noms de volumes et chemins privés sont volontairement omis ici ; les exemples de procédure permettent de refaire leur découverte localement.

Maillon Observation consignée Portée de la preuve
Travail applicatif Messages Updating CVEs, puis différents fichiers nvdcve-2.0-…json.gz Import progressant ; aucun pourcentage ni horaire de fin déductible
Écrivain Backend PostgreSQL identifié avec gvmd ... COPY, walwriter et background writer Écritures réelles de la base, pas seulement un téléchargement
Attribution PID hôte et cgroups rattachés au conteneur PostgreSQL Lien entre écrivains et conteneur, pas simple ressemblance de noms
Emplacement Source du volume inspectée puis contrôlée avec findmnt Base sur le support système, et non sur le NVMe supposé
E/S bloc Trois échantillons de deux secondes : écritures 14,88 / 4,60 / 36,85 MiB/s ; w_await 25,36 / 80,45 / 30,03 ms Pression d’écriture et latences pendant ces intervalles ; pas débit maximal matériel
Durabilité Checkpoint : write=269.535 s, sync=496.984 s, total=785.270 s Phase de synchronisation importante, recoupée avec la pression bloc

Une sonde ciblée de dix secondes consignait environ 38,86 MiB/s pour le backend COPY et 8,40 MiB/s pour le walwriter. Elle n’était pas exhaustive et ne partageait pas exactement la fenêtre d’iostat : ces débits ne doivent pas servir à calculer une part du trafic physique, ni être additionnés à celui-ci.

Un rebuild NVT avait été annoncé terminé avant les messages d’import CVE. Il ne fallait pas appeler « rebuild encore en cours » toute activité observée ensuite. Les années des fichiers CVE n’étaient pas traitées dans l’ordre : ce n’était pas une barre de progression.

Les 785,270 secondes de checkpoint comprenaient 496,984 secondes de synchronisation. Les checkpoints suivants consignés duraient 162,834 et 134,962 secondes : la durée n’était pas constante. Les valeurs brutes de %util comprenaient 105,05 % dans un échantillon ; cette anomalie interdit d’en faire un pourcentage physique exact. La conclusion repose sur plusieurs preuves convergentes, pas sur ce chiffre isolé.

Aucune pagination active n’était observée dans le dernier intervalle utile de vmstat et la mémoire disponible était importante. L’absence d’erreur disque visible dans la fenêtre de journal interrogée n’excluait pas un défaut matériel. Aucun test SMART n’avait été réalisé : pression de stockage identifiée, santé du SSD non établie.

11.2 Dify : une anomalie séparée, pas une part de trafic inventée

Le journal applicatif de l’incident montrait une validation d’URL échouant sur une expression reçue littéralement au lieu de sa valeur résolue :

inner_api_url
Input should be a valid URL
input_value='${PLUGIN_DIFY_INNER_API_URL:-http://api:5001}'

Il s’agit d’un extrait assaini de la forme d’erreur, sans adresse propre au serveur. Les compteurs consignés étaient de 2 029 redémarrages vers 17 h 25, puis 8 725 lors d’une inspection de métadonnées à 23 h 34. Ces observations renforcent le constat d’un phénomène persistant ; elles ne donnent ni une cadence constante ni un débit disque.

Une boucle peut produire logs et initialisations répétés. Mais sa part n’avait pas été mesurée : ne pas la déclarer cause principale devant les écritures PostgreSQL effectivement attribuées. Le message identifie une substitution non résolue ; il ne prouve pas à lui seul quel fichier ou quel niveau Compose/environnement l’a introduite.

11.3 Vérifications ultérieures et limites

À 23 h 34–23 h 35, une inspection de métadonnées a re-confirmé le montage persistant PostgreSQL, le pilote de logs journald et l’usage de cgroup v2. Le label du conteneur de base désignait un lanceur de stack Compose, ce qui illustre l’intérêt de ne pas supposer un Quadlet par conteneur. Une capture podman stats de cette base affichait 0B / 0B : ce seul affichage n’établissait ni la fin de l’import ni l’absence d’E/S.

Ces contrôles ultérieurs n’étaient pas une nouvelle mesure complète d’activité disque et ne prouvent pas que la pression de 17 heures était encore identique six heures plus tard. Aucun correctif Dify ni déplacement de base n’est déclaré dans cette page. La rédaction et sa publication ne constituent pas une intervention de maintenance sur ces services.

12. Arbre de décision et suites sûres

  1. Pas d’E/S dans la fenêtre ? Répéter lors du symptôme ; vérifier le bon disque, les droits et les compteurs. Ne pas conclure sur une seule capture vide.
  2. Débit élevé, latences acceptables, travail qui progresse ? Import, sauvegarde ou indexation peut être attendu. Vérifier l’impact et la fin avant de changer la configuration.
  3. Latences/files élevées, attente applicative ? Identifier le volume et ses concurrents, les synchronisations et l’état matériel ; ne pas se limiter à la bande passante.
  4. Swap active ? Examiner pression mémoire et limites des cgroups. Une RAM hôte disponible n’exclut pas une limite mémoire propre au conteneur.
  5. Même erreur répétée et redémarrages qui augmentent ? Corriger la cause de démarrage avec autorisation, après lecture du lanceur et de la configuration. Masquer les logs n’est pas corriger la boucle.
  6. Erreurs bloc, resets ou délais noyau ? Prioriser protection des données et diagnostic matériel adapté. Ne pas lancer de benchmark ni de réparation de système de fichiers sur un volume monté.
  7. Migration envisagée ? Vérifier espace, performances, sauvegarde et restauration ; prévoir un arrêt propre de base et une copie cohérente. Ne pas déplacer une base vivante par simple copie de fichiers.

Après une correction autorisée, refaire la même fenêtre de mesures, avec même charge si possible : débit, latences, files, attente, progression et évolution des redémarrages. Le succès est un effet observé, pas seulement une commande retournant zéro. Ne pas arrêter une base au hasard : ses applications dépendantes peuvent entrer à leur tour en boucle.

13. Gabarit de conclusion reproductible

Heure et fuseau :
Symptôme observé et fenêtre de mesure :
Disque / système de fichiers concerné :
Débit / latence / file / pression mémoire :
PID hôte + rôle + preuve d'identité :
Conteneur + cgroup + service/lanceur :
Source du volume + destination applicative (rapport privé uniquement) :
Travail applicatif et extrait de journal horodaté :
Déclencheur confirmé, ou encore supposé :
Origine principale étayée :
Contributions secondaires non quantifiées :
Limites de droits, outils et fenêtres :
Changements autorisés / réellement appliqués :
Mesure après correction / prochaine vérification :

Dans un document public, conserver le raisonnement et les métriques utiles mais remplacer les identifiants, chemins, adresses et informations d’accès privés. Le rapport local détaillé garde les éléments nécessaires à l’exploitation ; les variables d’environnement complètes et les secrets n’ont leur place ni dans l’un ni dans l’autre.

14. Références et maintenance documentaire

  • iostat : manuel sysstat. Le premier rapport concerne le temps depuis le démarrage « unless the -y option is used ». Les définitions d’await, %util et les unités binaires y sont précisées.
  • pidstat : manuel sysstat : E/S par tâche et sélection des PID.
  • /proc/PID/io : manuel Linux. write_bytes : « The number of bytes really sent to the storage layer » ; lire aussi cancelled_write_bytes, les règles d’accès et l’inclusion des enfants attendus.
  • Cgroup v2 : documentation du noyau, contrôleur I/O. Définit io.stat, les compteurs par périphérique et les limites du writeback attribuable.
  • Podman inspect : inspection et formats Go. Pour stats et les descripteurs de top, consulter aussi man podman-stats et podman top --help de la version installée ; le manuel stats local a été consulté lors de la rédaction.
  • Podman Quadlet : génération des unités et application de [Install].
  • systemd.service : sens des politiques de redémarrage.
  • PostgreSQL : WAL et checkpoints : durabilité, étalement des checkpoints et charge d’E/S. La page courante décrit une version récente ; vérifier les paramètres disponibles dans la version réellement déployée avant tout réglage.

Guide rédigé le 18 octobre 2026. Mettre à jour les exemples si les propriétés Podman, le pilote de logs, la hiérarchie cgroup, le lanceur ou le stockage changent. Conserver les mesures historiques avec leur date au lieu de les transformer en état courant. Les pages de navigation du wiki donnent accès à ce guide ; il ne décrit pas un nouveau service à déployer.

15. Déroulement de la recherche : des symptômes aux preuves

Complément documentaire du 19 octobre 2026, consacré à l'enquête du 18 octobre 2026. Il ne constitue pas une nouvelle mesure de l'état des services. La section 11 conserve les autres fenêtres historiques ; les chiffres ci-dessous ne les remplacent pas.

Ce récit explique pourquoi chaque sonde a été choisie, ce qu'elle permettait de conclure et pourquoi certaines pistes ont nécessité un autre outil. Les commandes courtes reprennent les options effectivement utilisées. Pour cette publication publique, les noms de conteneurs, PID, chemins privés et identifiants sont remplacés par des exemples ou variables. Les scripts sont des retranscriptions commentées et assainies de la méthode employée, pas une prétendue nouvelle exécution. Les valeurs d'exemple sont à découvrir à nouveau avant toute utilisation.

15.1 Fil directeur et ordre de l'enquête

  1. Dater et inventorier, sans installer d'outil ni changer la charge.
  2. Mesurer le stockage, pour distinguer une écriture soutenue d'un simple disque plein.
  3. Écarter une pagination active comme explication principale, puis rechercher les tâches bloquées.
  4. Chercher les écrivains, et constater que les permissions rendent une partie des compteurs illisibles.
  5. Contourner cette limite dans le périmètre rootless autorisé, puis rapprocher processus et conteneurs.
  6. Lire les journaux applicatifs et PostgreSQL, pour identifier le travail demandé et ses attentes de durabilité.
  7. Tenter une confirmation SQL bornée, sans inventer de résultat après expiration.
  8. Refaire une courte mesure du disque, puis formuler une conclusion limitée aux preuves disponibles.

Les points 2 et 3 ont fait l'objet de collectes parallèles ; les autres sondes ne sont pas toutes synchrones. Cet ordre est celui du raisonnement, pas une promesse que toutes les commandes ont observé exactement la même seconde. La partie systemd du guide général fournit le prolongement vers le lanceur et le déclencheur : il serait faux de déduire le timer responsable à partir des seuls journaux d'import.

15.2 Première étape : dater, identifier et inventorier

date --iso-8601=seconds
hostname
uname -sr
command -v iostat pidstat iotop vmstat podman
uptime
lsblk -o NAME,TYPE,SIZE,ROTA,FSTYPE,MOUNTPOINTS
free -h
  • date --iso-8601=seconds produit une date avec fuseau et précision à la seconde. Ce repère permet de comparer une mesure locale aux journaux UTC.
  • hostname, sans option, identifie l'hôte de collecte. Son résultat n'est pas reproduit ici : il ne doit pas devenir un inventaire public.
  • uname -sr regroupe -s, nom du noyau, et -r, version publiée du noyau ; cela situe l'environnement de mesure.
  • command -v demande au shell la résolution de chaque nom dans son environnement. Il ne lance ni les outils recherchés ni une installation. iotop a été recherché, pas exécuté.
  • uptime, sans option, donne la durée de fonctionnement et les moyennes de charge sur une, cinq et quinze minutes. Des tâches bloquées peuvent augmenter cette charge sans saturer les CPU.
  • lsblk -o choisit les colonnes : NAME nom du périphérique, TYPE nature, SIZE capacité, ROTA caractère rotatif annoncé, FSTYPE système de fichiers, MOUNTPOINTS montages. Cette première liste ne mesure pas de débit et ne prouve pas encore où réside un volume Podman.
  • free -h affiche RAM et swap avec unités lisibles. L'objectif est de rechercher une pression mémoire possible, pas d'assimiler le cache à de la mémoire perdue.

Pourquoi commencer ici ? Pour ne pas appliquer une sonde à un disque supposé, confondre la charge avec le CPU, ou interpréter des journaux dans des fuseaux différents. Le rattachement définitif du volume au support demande ensuite les contrôles de la section 7.

15.3 Deuxième étape : mesurer débit, file et latence du stockage

iostat -x -y -z -t sda sdb sdc nvme0n1 2 6
  • -x active les statistiques étendues : latences, tailles de requêtes, file et activité.
  • -y supprime le premier rapport cumulé depuis le démarrage : on veut l'incident actuel, pas sa moyenne avec toute la vie du serveur.
  • -z masque les périphériques sans activité sur l'intervalle. L'absence d'une ligne ne démontre donc pas l'absence du périphérique.
  • -t ajoute l'heure de chaque rapport.
  • La liste de périphériques sélectionne les cibles. Ici, ces noms sont ceux de la commande historique ; les adapter à l'inventaire avant de rejouer la sonde.
  • 2 6 demande six rapports à deux secondes d'intervalle. Le délai d'exécution externe était de trente secondes.

Observation retrouvée dans la sortie originale : les rapports de 17:07:02 à 17:07:12 montrent des écritures sur le disque système. Par exemple, le rapport de 17:07:06 donne wkB/s=1104,00, w_await=228,57 ms et %util=99,05. Deux secondes auparavant, le débit était beaucoup plus élevé et l'attente moyenne plus faible. Un faible débit ne suffit donc pas à écarter une gêne du stockage.

Ce que cela change dans l'enquête : l'activité n'est pas simplement une question de capacité occupée ; il faut chercher les écrivains et les synchronisations. Ce relevé n'identifie ni le logiciel responsable ni une panne matérielle.

15.4 Troisième étape : mémoire et processus en attente

vmstat -w 2 7
ps -eo pid,ppid,user,stat,comm,wchan:32 --sort=stat
  • vmstat -w élargit l'affichage ; 2 7 demande sept rapports espacés de deux secondes.
  • Le premier rapport contient notamment des moyennes de CPU et de débit depuis le démarrage ; les six suivants décrivent les intervalles courants.
  • r compte les tâches exécutables, b les tâches bloquées ; si/so mesurent les transferts de swap ; bi/bo les transferts bloc ; wa l'attente d'E/S côté CPU.
  • ps -e sélectionne tous les processus ; -o choisit les colonnes ; l'écriture combinée -eo regroupe ces deux options.
  • pid/ppid sont les PID du processus et du parent ; user le propriétaire ; stat l'état ; comm le nom ; wchan:32 le canal d'attente noyau sur une largeur de 32 caractères.
  • --sort=stat classe par état. Ce tri n'est pas un classement de débit disque.

Résultats : les intervalles courants de cette capture ont si=0 et so=0, alors que le premier rapport affiche des échanges historiques non nuls. Plusieurs tâches sont bloquées, dont deux processus PostgreSQL avec stat=Ds et wchan=rq_qos_wait.

D signifie attente non interruptible ; s indique ici un leader de session, pas une intensité d'E/S. Le canal rq_qos_wait oriente vers une attente dans la régulation des requêtes bloc, sans prouver à lui seul une défaillance physique.

Décision : ne pas accuser le swap parce qu'il est déjà occupé. Examiner les processus PostgreSQL, sans conclure qu'ils expliquent à eux seuls tout le trafic.

15.5 Quatrième étape : attribution par pidstat et limite de permissions

pidstat -d -h -p ALL 2 6
  • -d sélectionne les statistiques d'E/S par tâche : lectures, écritures, écritures annulées et délai d'E/S si disponible.
  • -h conserve une présentation horizontale et supprime la moyenne finale.
  • -p ALL sélectionne tous les processus, au lieu d'une liste de PID séparés par des virgules.
  • 2 6 demande six rapports à deux secondes d'intervalle.

Limite réellement rencontrée : de nombreuses colonnes contiennent -1,00. Ce ne sont ni des débits négatifs réels ni la preuve d'une absence d'activité : les compteurs ne sont pas accessibles au compte de collecte.

Le retraitement Python a relu la sortie enregistrée, séparé les colonnes, converti les décimales françaises avec float(valeur.replace(',', '.')), distingué les valeurs négatives et classé les débits lisibles. Un premier filtre avait produit un comptage erroné ; la relecture corrigée compte 475 PID distincts aux compteurs inaccessibles, et non un total d'écrivains. Une ligne par échantillon ne doit pas être comptée comme un nouveau processus.

Les scripts de retraitement utilisaient json.loads() pour lire le champ output de la réponse enregistrée, et Path.read_text() pour charger le fichier. Ils n'étaient pas des mesures supplémentaires. Le filtrage des lignes D de la sortie ps ne refaisait pas non plus un instantané des processus.

Décision : ne pas désigner le plus gros écrivain visible comme gagnant d'un classement largement aveugle. Vérifier l'accès rootless aux processus de conteneurs appartenant au compte.

15.6 Cinquième étape : client Podman lent et tests séparés

podman ps --format '{{.ID}} {{.Names}} {{.Status}}'
df -hT /
sudo -n true
journalctl -k --since '-20 min' -p warning --no-pager -n 60
  • podman ps, sans -a, liste les conteneurs en cours ; --format limite la sortie aux identifiants, noms et états. Les accolades sont un modèle Go transmis littéralement grâce aux apostrophes du shell.
  • df -hT / examine le système de fichiers contenant / : -h affiche des unités lisibles et -T le type. Cela mesure le remplissage, pas le débit.
  • sudo -n true teste l'autorisation de lancer la commande inoffensive true sans interaction. -n interdit l'invite de mot de passe. Même une réussite ne prouverait pas l'autorisation de toute autre commande sudo.
  • journalctl -k sélectionne les messages noyau ; --since '-20 min' borne l'ancienneté ; -p warning inclut avertissements et niveaux plus graves ; --no-pager retire la pagination ; -n 60 limite le nombre d'entrées.

Échec utile : une première séquence commençait par podman ps, puis enchaînait df et le test sudo avec ;. L'appel a expiré après trente secondes. On ne pouvait pas déclarer que les trois sous-commandes avaient répondu. Les contrôles ont donc été séparés du client Podman susceptible de bloquer.

Une absence de message noyau dans cette sélection ne couvre ni tous les journaux, ni toute la durée de l'incident, ni les compteurs SMART. Aucun diagnostic SMART n'a été exécuté dans cette enquête. La documentation générale conserve les observations de capacité et mémoire ; elles ne remplacent pas une mesure des E/S.

15.7 Sixième étape : sonder les compteurs dans l'espace utilisateur rootless

L'enveloppe de commande utilisée était :

timeout 20s podman unshare python3 - <<'PY'
from pathlib import Path
import time

# Deux lectures, sans toucher aux fichiers de données des applications.
def snapshot():
    result = {}
    for p in Path('/proc').iterdir():
        if not p.name.isdigit():
            continue
        try:
            data = dict(
                (k, int(v))
                for k, v in (
                    line.split(':')
                    for line in (p / 'io').read_text().splitlines()
                )
            )
            result[p.name] = (data, (p / 'comm').read_text().strip())
        except (OSError, ValueError):
            # Un processus inaccessible ou déjà disparu manque à la collecte.
            pass
    return result

start = time.monotonic()
a = snapshot()
time.sleep(5)
b = snapshot()
elapsed = time.monotonic() - start
rows = []
for pid, (data, name) in b.items():
    if pid not in a:
        continue
    old = a[pid][0]
    rd = (data['read_bytes'] - old['read_bytes']) / elapsed / 1024
    wr = (data['write_bytes'] - old['write_bytes']) / elapsed / 1024
    if rd + wr > 0:
        rows.append((rd + wr, pid, name, rd, wr))
print('Intervalle réel (s):', round(elapsed, 2), 'PID lisibles:', len(b))
print('PID NOM LECTURE_Kio/s ECRITURE_Kio/s')
for _, pid, name, rd, wr in sorted(rows, reverse=True)[:20]:
    print(pid, name, round(rd, 2), round(wr, 2))
PY
  • timeout 20s borne l'attente du client à vingt secondes, distinctement du délai de l'outil qui l'appelle.
  • podman unshare lance le programme dans un espace de noms utilisateur adapté aux UID rootless du compte. Ce n'est pas un accès root global à l'hôte, ni une entrée dans le système de fichiers d'un conteneur.
  • python3 - lit le programme sur l'entrée standard ; <<'PY' introduit un heredoc dont le contenu n'est pas développé par le shell. PY seul termine ce contenu.
  • Path('/proc').iterdir() parcourt les entrées de processus ; isdigit() exclut les autres fichiers de /proc.
  • read_bytes et write_bytes sont des compteurs cumulés ; la différence entre les deux captures, divisée par la durée réelle puis par 1024, donne ici des Kio/s, pas des MiB/s.
  • time.monotonic() évite une durée faussée par un réglage de l'heure civile ; sleep(5) espace les captures. Les parcours eux-mêmes prennent du temps : la fenêtre est approximative et non atomique.
  • Le tri retient les vingt plus forts débits lisibles ; les exceptions ignorées correspondent à des données absentes, pas à des zéros.

Limite de cette première sonde : elle ne vérifiait pas le champ starttime de /proc/PID/stat. Elle pouvait manquer les processus courts ou mal traiter un PID réutilisé. Elle capturait comm avec les compteurs, mais pas encore systématiquement cmdline et cgroup. Une amélioration est de relever l'identité complète et starttime dans les mêmes captures, puis d'écarter les identités changées.

La commande originale complétait ce classement par la lecture de cmdline des deux processus bloqués. Les arguments y sont séparés par l'octet nul ; le script remplaçait b'\0' par un espace avant affichage. Pour réutiliser la méthode, choisir les PID observés dans la capture courante, jamais ceux d'un ancien rapport.

Portée : c'est une attribution partielle par processus, pas un bilan exhaustif du disque. Les résultats ne doivent être additionnés ni aux compteurs cgroups ni aux écritures iostat.

15.8 Septième étape : retrouver le conteneur et tenter les cgroups

Deux compléments ont été utilisés avec python3 - <<'PY' :

  1. Lire le catalogue local containers.json, puis n'afficher que les champs id et names. Le chemin dépend du graphroot réel. Il est volontairement absent de cette publication ; ne pas recopier un emplacement supposé. Cette lecture de fichier évitait d'attendre podman ps, mais n'apportait pas à elle seule une preuve d'activité du conteneur.
  2. Parcourir les fichiers io.stat dans la branche cgroup du compte, retenir les scopes libpod-…scope, prendre deux lectures espacées de cinq secondes et afficher les contenus non vides qui avaient changé.

Dans le code, json.loads() décode le catalogue, c.get('id') et c.get('names') sélectionnent les seuls champs utiles ; Path.rglob('io.stat') parcourt la sous-arborescence ciblée ; read_text() charge les compteurs ; time.sleep(5) espace les deux lectures. Ce n'était ni un parcours de tous les fichiers du serveur ni une inspection intégrale des configurations.

Le lien recherché était : identifiant du cgroup du PID → identifiant libpod → nom dans le catalogue. Le chemin de cgroup reste une métadonnée d'attribution ; il ne donne pas le chemin des données PostgreSQL. Le rapprochement vers le disque utilise ensuite les montages et findmnt, comme expliqué dans les sections 5 à 7.

Limites de la tentative : la comparaison de textes avant/après ne calculait pas encore un débit agrégé normalisé. Des fichiers vides, des écritures attribuées ailleurs ou une hiérarchie mal choisie empêchent une conclusion quantitative. On ne publie donc pas un pourcentage du trafic de chaque conteneur à partir de ce seul essai. Les mesures cgroups sont hiérarchiques : ne pas sommer parent et descendants.

15.9 Huitième étape : inspection ciblée et processus disparu

Une inspection bornée a ensuite visé deux PID relevés pendant l'enquête :

# Forme assainie : choisir les PID actuels avant utilisation.
timeout 15s podman unshare python3 - "$PID_A" "$PID_B" &lt;&lt;'PY'
from pathlib import Path
import sys

for pid in sys.argv[1:]:
    if not pid.isdigit():
        raise SystemExit('PID numérique requis')
    p = Path('/proc') / pid
    print('PID', pid)
    for name in ('cmdline', 'cgroup'):
        try:
            print(name, (p / name).read_bytes().replace(b'\0', b' ').decode(errors='replace').strip())
        except OSError as e:
            print(type(e).__name__)
    try:
        targets = []
        for fd in (p / 'fd').iterdir():
            try:
                target = str(fd.readlink())
                if '/base/' in target or 'pg_wal' in target or target.endswith('.log'):
                    targets.append(target)
            except OSError:
                pass
        print('Fichiers de données/journal ouverts (20 max):', sorted(set(targets))[:20])
    except OSError as e:
        print(type(e).__name__)
PY
  • timeout 15s borne cet essai à quinze secondes ; cette commande a expiré avec le code 124, sans résultat exploitable.
  • Les PID étaient codés dans le script historique ; ici, "$PID_A" "$PID_B" les transmet comme arguments et sys.argv[1:] les récupère. C'est une adaptation d'anonymisation, pas une option supplémentaire exécutée à l'époque.
  • cmdline indique la commande ou le rôle ; cgroup aide au rattachement ; fd.readlink() ne lit que la cible d'un descripteur, pas le contenu du fichier.
  • Le filtre /base/, pg_wal ou suffixe .log cherchait des noms de données ou de journaux PostgreSQL ; set() déduplique et [:20] borne l'affichage, pas nécessairement le nombre de liens parcourus.

Une lecture directe ultérieure de cmdline et cgroup, hors unshare, a renvoyé deux fois FileNotFoundError pour l'un des PID. Le processus n'était plus présent sous ce PID au moment de la sonde. Cela ne permettait ni de refaire son attribution individuelle ni d'annoncer la fin de l'import. La bonne leçon est de collecter l'identité avec les compteurs, pas plusieurs minutes après.

15.10 Neuvième étape : les journaux expliquent le travail demandé

# Noms fictifs ; la sonde historique visait la base et le gestionnaire Greenbone.
C_DB='mon-conteneur-postgresql'
C_APP='mon-conteneur-importeur'
timeout 15s podman logs --tail 60 "$C_DB"
timeout 15s podman logs --tail 60 "$C_APP"
  • Les affectations définissent des variables du shell ; les guillemets autour de "$C_DB" et "$C_APP" préservent chaque nom comme un argument unique.
  • podman logs lit stdout/stderr conservés par le pilote du conteneur. Ce n'est pas une lecture automatique de tous les fichiers de logs internes.
  • --tail 60 limite chaque consultation aux soixante dernières lignes ; il n'impose pas une période de soixante secondes.
  • Chaque client est borné séparément par timeout 15s. Ces consultations ont produit des extraits exploitables.

Extraits assainis des journaux applicatifs :

2026-10-18 13:42:57 UTC  Updating CPEs
2026-10-18 13:43:32 UTC  Rebuilding all NVTs because of a hash value mismatch
2026-10-18 13:55:18 UTC  Updating VTs in database ... 190009 new VTs, 0 changed VTs
2026-10-18 13:55:32 UTC  update_nvt_cache_retry: rebuild successful
2026-10-18 15:07:03 UTC  Updating CVEs

Les préfixes, PID et chemins des messages sont retirés ; les heures et messages utiles sont conservés. La reconstruction NVT était terminée avant les messages CVE de la fenêtre mesurée. Le travail en cours ne devait donc pas être décrit comme une reconstruction NVT encore active. Les fichiers CVE successifs indiquaient une progression d'import, pas un pourcentage ni une heure de fin.

Extrait PostgreSQL, dans la même collecte de journaux :

2026-10-18 15:09:50.129 UTC
checkpoint complete:
write=146.888 s, sync=378.801 s, total=558.321 s
sync files=17, longest=216.876 s, average=22.283 s

Il s'agit d'un autre checkpoint que celui de 785,270 secondes déjà conservé en section 11. Les valeurs ne sont pas contradictoires : elles décrivent des opérations distinctes. write caractérise la phase d'écriture, qui peut être étalée volontairement ; sync la phase de synchronisation ; total inclut l'ensemble de l'opération et ne se réduit pas forcément à la somme de ces deux champs. longest et average décrivent les synchronisations de fichiers du checkpoint.

Décision : relier l'import applicatif aux écritures et à la pression de synchronisation PostgreSQL. Ce rapprochement est plus solide qu'une simple ressemblance de noms de processus. Il ne démontre pas pourquoi le matériel répond lentement, ni que tous les octets du disque appartiennent à Greenbone.

15.11 Dixième étape : tentative SQL en lecture seule, restée sans résultat

# Conteneur fictif ; gvmd est ici le nom applicatif de la base interrogée.
timeout 20s podman exec --user postgres "$C_DB" \
  psql -X -w -d gvmd -P pager=off -c "BEGIN READ ONLY; SET LOCAL statement_timeout = '5s'; SELECT pid, backend_type, datname, state, wait_event_type, wait_event, clock_timestamp()-query_start AS duree, left(query,180) AS requete FROM pg_stat_activity WHERE state = 'active' AND pid &lt;&gt; pg_backend_pid(); COMMIT;"
  • podman exec lance un client dans un conteneur existant ; contrairement à unshare, c'est ici l'environnement du conteneur qui est utilisé.
  • --user postgres sélectionne le compte d'exécution du client dans le conteneur, pas une élévation root sur l'hôte.
  • psql -X ignore le fichier de démarrage personnel ; -w interdit l'invite de mot de passe ; -d gvmd sélectionne la base ; -P pager=off désactive le paginateur ; -c fournit la chaîne SQL au client.
  • BEGIN READ ONLY ouvre une transaction interdisant les écritures ordinaires de cette session. Cette sonde ne change pas les paramètres persistants de la base, mais la connexion et l'exécution ont un coût et peuvent être journalisées.
  • SET LOCAL statement_timeout = '5s' borne les instructions côté serveur dans cette transaction ; ce délai ne couvre pas le démarrage de Podman ni l'établissement de la connexion.
  • pg_stat_activity expose les sessions ; backend_type leur rôle ; state leur état ; wait_event_type/wait_event leur attente éventuelle.
  • clock_timestamp()-query_start calcule une durée selon l'horloge au moment de lecture ; left(query,180) limite le texte affiché à 180 caractères, sans garantir son anonymisation.
  • state = 'active' retient les sessions actives ; pid <> pg_backend_pid() exclut la sonde elle-même ; COMMIT termine la transaction.

Résultat : expiration globale, code 124, sortie vide. Impossible de distinguer avec cet essai seul une attente dans le client Podman, la connexion ou SQL. Aucune ligne de pg_stat_activity n'a été obtenue : il serait faux de lui attribuer la preuve de COPY ou d'un verrou précis. La troncature des requêtes n'aurait d'ailleurs pas suffi à rendre leurs valeurs publiables.

15.12 Onzième étape : courte contre-mesure du disque

date --iso-8601=seconds
iostat -x -y -z -t sda 2 3

Les options ont le même sens qu'à la première collecte ; la cible est réduite au périphérique suivi et le nombre de rapports à trois. L'heure initiale était 2026-10-18T17:13:13+02:00. Voici les valeurs de la sortie originale, avec leurs libellés d'unité, sans conversion de débit :

Heure de Paris rkB/s wkB/s w_await (ms) aqu-sz %util %iowait CPU
17:13:15 2,00 63 418,00 12,81 6,14 98,30 15,08
17:13:17 0,00 17 410,00 49,59 9,19 99,65 15,03
17:13:19 0,00 47 882,00 53,20 7,50 99,20 16,06

Interprétation : activité presque continue, principalement en écriture, avec une file persistante et des latences d'écriture importantes sur cette courte fenêtre. Les CPU restaient majoritairement inactifs dans ces rapports. Ce relevé ne donne ni débit maximal du SSD ni part exacte de chaque application. Ce n'est pas non plus une mesure après correction : aucun correctif n'avait été appliqué.

15.13 Lire correctement le shell et les codes de retour

  • commande1 ; commande2 enchaîne même si la première échoue. Le statut final d'une séquence ne valide pas chaque étape. Un client bloqué au début retarde les commandes suivantes.
  • timeout 15s et timeout 20s bornent une commande particulière ; le délai de l'outil d'exécution est une autre limite. Le code 124 signale ici une expiration, pas un arrêt de la base. Sans option d'escalade supplémentaire, ce n'est pas une garantie de terminaison instantanée d'une tâche bloquée dans le noyau.
  • Un code nul signifie que le programme a terminé sans erreur signalée ; il ne prouve ni exhaustivité des données ni réussite de toutes les lectures si le script ignore des exceptions.
  • python3 - <<'PY' fournit le programme par stdin ; python3 -c '...' fournit directement une chaîne de programme. Les scripts utilisés pour relire JSON et /proc n'étaient pas des commandes SQL ni des actions de maintenance.
  • Les lectures ciblées de /proc/PID/comm, cmdline, cgroup, io et liens fd portent sur des métadonnées. Les permissions et la durée de vie des processus restent des limites. Ne jamais publier les arguments bruts sans vérifier qu'ils ne contiennent pas de secret.

15.14 Conclusion, degré de certitude et suites non exécutées

Origine fonctionnelle principale étayée : l'import de données de vulnérabilités Greenbone demandait du travail à PostgreSQL. Les journaux d'import, les écrivains de base consignés dans l'incident, les checkpoints avec une longue phase de synchronisation et les latences bloc forment un faisceau cohérent. La reconstruction NVT terminée est un antécédent, pas une preuve qu'elle occupait encore le disque à 17 h 13.

Ce qui reste inconnu : la répartition exhaustive des octets entre services ; le responsable de chaque processus court disparu ; la raison matérielle ou logicielle précise des synchronisations lentes ; le déclencheur systemd exact de ce travail pour cette fenêtre ; l'état SMART ; l'heure de fin de l'import. L'anomalie Dify déjà documentée reste distincte et non quantifiée en débit.

Actions non réalisées par cette enquête : aucun arrêt ou redémarrage de service, suppression, vidage de cache, modification de la durabilité PostgreSQL, déplacement de volume, benchmark ou réparation. Le complément présent est documentaire. Les commandes systemd du guide sont des moyens de poursuivre l'attribution, pas une déclaration qu'une unité a été modifiée.

Vérifications à faire après autorisation ou au prochain suivi : refaire la même fenêtre après la fin constatée de l'import ; vérifier si les latences persistent hors import ; examiner alors la santé du stockage, les concurrents du volume et la planification. Ne pas redémarrer à l'aveugle une base dont les journaux montrent une progression.

15.15 Références pour reproduire et interpréter