Résumé exécutif

Le 07-09, plusieurs VMs hébergées sur asgard (Proxmox + Ceph) ont basculé au boot en initramfs avec demande de fsck manuel. La cause racine est la disparition temporaire du NVMe qui porte la DB/WAL d’un OSD de 10 To : l’OSD a “flappé” pendant un redémarrage, générant des gels d’E/S côté RBD. Les FS ext4 des invités ont détecté des incohérences (journal à rejouer) et ont exigé une réparation interactive. Sur plusieurs VMs, fsck échouait avec des I/O errors, car les disques invités étaient rouverts en lecture seule (état de lock RBD/QEMU après le flap).
Nous avons réparé hors invité (depuis l’hôte) et tout est revenu à la normale. Aucun signe de perte de données applicatives.

Impact

• VMs affectées (confirmées) : PBS (811), 1240, 333, 30101 ; probablement d’autres VMs du nœud asgard.

• Symptômes :

  • Écran (initramfs) avec fsck exited with status code 4 / UNEXPECTED INCONSISTENCY.

  • Sur plusieurs VMs : Input/output error … unable to set superblock flags lors de e2fsck, et message GRUB failure writing sector … to hd0 → disque vu RO.

• Cluster Ceph : revenu rapidement en HEALTH_OK (6/6 OSD up+in) après reboot du nœud ; pas de dégradation durable.

Chronologie (approx.)

• ~08:30 : le NVMe (DB/WAL d’un OSD 10 To) disparaît, redémarrage d’asgard pour vérification BIOS/CMOS → le NVMe réapparaît.

• 08:49 : redémarrage des OSDs (logs osd.2, osd.5), messages BlueStore de reconstruction de l’allocateur (attendu après arrêt non propre).

• Après reboot : plusieurs VMs sur asgard bootent en initramfs et/ou voient leurs disques RO.

• Journée : réparations successives (cf. “Ce qui a été fait”), retour à la normale.

Diagnostic

1. Côté invité : ext4 demande un fsck → normal après gels d’E/S.

2. Maisfsck échoue sur certaines VMs : I/O error → disque ouvert RO par QEMU/RBD (exclusive-lock/watchers “stuck” après le flap/snapshots tentés).

3. Côté cluster : pas d’erreurs Ceph persistantes ; HEALTH_OK.

4. Conclusion : problème transitoire I/O → incohérences ext4 + état RO au niveau RBD/QEMU à lever.

Cause racine

• Disparition/re-apparition du NVMe DB/WAL d’un OSD (câble/slot/firmware/APST/PCIe power-states) ⇒ freeze d’E/S sur certaines images RBD ⇒ ext4 marque le FS “dirty” et bloque au boot.

• Contribuant : locks RBD/watcher résiduels (exclusive-lock) après les flaps/snapshots, amenant QEMU/ISO à rouvrir le disque en RO, empêchant fsck d’écrire le superblock.

Ce qui a été fait (remédiation)

• Stabilisation cluster : vérification ceph -s (HEALTH_OK). Utilisation temporaire de noout pendant certaines manips (puis unset).

• VM 333 :

  • rbd map → partprobe (création /dev/rbd0p*) → e2fsck -f -y /dev/rbd0p2 (ext4) → rbd unmap → qm start 333. ✅

• VM PBS (811) :

  • rbd map → activation du VG pbs malgré le filtre LVM (--config 'devices { global_filter = … }') → e2fsck -f -y /dev/pbs/root (erreurs corrigées) → vgchange -an → rbd unmap → qm start 811. ✅

• VM 1240 : même approche (host-side fsck) après essais initramfs/ISO infructueux. ✅

• VM 30101 : ext4 direct sur /dev/rbd0p1 + EFI vfat sur p15 → e2fsck puis reboot. ✅

• Contrôles : services PBS up, verify/GC, Ceph HEALTH_OK.

Risque données

• Faible. ext4 a été réparé par e2fsck (journal rejoué, compteurs corrigés). Pas de corruption applicative observée. PBS a redémarré proprement et les datastores sont lisibles.

Actions correctives & préventives (recommandées)

Matériel/OSD (cause racine)

• NVMe (DB/WAL) :

  • Vérifier firmware et santé : nvme smart-log, smartctl -a, dmesg | egrep -i 'nvme|pcie|AER|timeout|reset'.

  • Désactiver APST/profondeurs d’économie si contrôleur capricieux : ajouter sur asgard
    nvme_core.default_ps_max_latency_us=0 (GRUB) puis redémarrage planifié.

  • Miroir/RAID1 pour DB/WAL si possible (éviter le SPOF d’un seul NVMe).

• Procédures maintenance Ceph :

  • ceph osd set nooutavant intervention, unset juste après.

  • Scripting de check : refuser tout reboot si ceph health ≠ OK.

Invités/VMs

• Auto-réparation au boot (Ubuntu/Debian) :
  fsck.mode=force fsck.repair=yes dans GRUB_CMDLINE_LINUX_DEFAULT + update-grub.
  ⇒ la VM répare seule et ne s’arrête plus en initramfs.

• Runbook “host-side fsck” (3 lignes) pour futures urgences :

                              qm stop <id>; rbd map <pool>/<img>; partprobe /dev/rbdX; \
  vgchange -ay; e2fsck -f -y <LV ext4 ou /dev/rbdXpY>; vgchange -an; \
  rbd unmap /dev/rbdX; qm start <id>
  
                            

• Snapshots :

  • Limiter les snapshots “long terme” (1–3 max / VM) ; privilégier PBS pour la rétention.

  • Supprimer les vieux snapshots en heures creuses.

Supervision/alerting

• Alerte sur disque NVMe manquant (SMART/PCIe), et sur flags Ceph (noout/noup laissés actifs).

• Alerte sur VM en boot loop/initramfs (via Proxmox API + syslog).

Leçons apprises

• Un flap DB/WAL peut suffire à faire geler des invités malgré un cluster vite “green”.

• Quand fsck échoue en I/O depuis l’invité, réparer depuis l’hôte (map RBD + e2fsck) est rapide et fiable.

• Ne pas oublier d’unset noout et de nettoyer les snapshots pris pendant l’incident.

État final

• Ceph : HEALTH_OK.

• PBS (811) et VMs concernées : opérationnelles.

• Données : pas d’incohérences observées après e2fsck.

Utilisation express

                                
                        
                          ./host-fsck.sh 333 
                        
                        
                        

                        
                                
                        
                          ./host-fsck.sh 811 --efi # lance aussi fsck.vfat sur l’EFI si trouvé 
                        
                      

Le script :

• stoppe la VM,

• lève les locks RBD résiduels,

• mappe l’image (avec les bons creds du storage),

• crée les devices de partitions,

• détecte la racine (ext4 directe ou via LVM) et lance e2fsck -f -y,

• (optionnel) répare l’EFI en vfat,

• nettoie et redémarre la VM.

                        

                        
                          #!/usr/bin/env bash
                          

                          # host-fsck.sh — Réparer un système de fichiers d'une VM Proxmox stockée sur Ceph RBD
                          

                          # Exécuter sur l'hôte Proxmox. Répare la racine ext4 (ou via LVM) et redémarre la VM.
                          

                          # Usage: ./host-fsck.sh <VMID> [--efi]
                          

                          #   --efi : tente aussi un fsck.vfat sur la partition EFI si détectée
                          

                          #
                          

                          # Notes:
                          

                          # - Tolère l'absence de "kpartx" (utilise partprobe à la place).
                          

                          # - Gère les locks RBD résiduels (blocklist automatique des watchers).
                          

                          # - Contourne le filtrage LVM sur /dev/rbd* via --config local.
                          

                          # - N'interrompt PAS sur e2fsck non‑zéro (1=errors corrected, etc.).
                          

                          set -uo pipefail
                          

                          RED=$'\e[31m'; GRN=$'\e[32m'; YLW=$'\e[33m'; BLU=$'\e[34m'; CLR=$'\e[0m'
                          

                          msg() { echo "${BLU}[*]${CLR} $*"; }
                          

                          ok()  { echo "${GRN}[ok]${CLR} $*"; }
                          

                          warn(){ echo "${YLW}[!]${CLR} $*"; }
                          

                          err() { echo "${RED}[x]${CLR} $*" >&2; }
                          

                          die() { err "$*"; exit 1; }
                          

                          [[ $EUID -eq 0 ]] || die "Doit être exécuté en root sur l'hôte Proxmox."
                          

                          [[ ${1:-} ]]      || die "Usage: $0 <VMID> [--efi]"
                          

                          VMID=$1; shift || true
                          

                          DO_EFI=false
                          

                          while [[ ${1:-} ]]; do
                          

                            case "$1" in
                          

                              --efi) DO_EFI=true;;
                          

                              *) die "Option inconnue: $1";;
                          

                            esac
                          

                            shift || true
                          

                          done
                          

                          # 1) Stopper la VM
                          

                          msg "Arrêt de la VM $VMID"
                          

                          qm stop "$VMID" >/dev/null 2>&1 || true
                          

                          sleep 1
                          

                          # 2) Trouver le disque de boot (ordre de préférence)
                          

                          DISK_LINE=$(qm config "$VMID" | awk '/^(scsi0|virtio0|sata0|ide0):/{print; exit}')
                          

                          if [[ -z "$DISK_LINE" ]]; then
                          

                            DISK_LINE=$(qm config "$VMID" | awk '/^(scsi|virtio|sata|ide)[0-9]+:/{print; exit}')
                          

                          fi
                          

                          [[ -n "$DISK_LINE" ]] || die "Impossible de déterminer le disque de la VM (qm config)."
                          

                          STORAGE=$(sed -nE 's/^[^ ]+: ([^:]+):([^,]+).*/\1/p' <<<"$DISK_LINE")
                          

                          IMAGE=$(  sed -nE 's/^[^ ]+: ([^:]+):([^,]+).*/\2/p' <<<"$DISK_LINE")
                          

                          [[ -n "$STORAGE" && -n "$IMAGE" ]] || die "Stockage ou image introuvable dans: $DISK_LINE"
                          

                          # 3) Résoudre le pool/credentials depuis /etc/pve/storage.cfg
                          

                          SCFG=/etc/pve/storage.cfg
                          

                          [[ -r $SCFG ]] || die "Fichier $SCFG introuvable."
                          

                          POOL=$(awk -v s="$STORAGE" '$1=="rbd:"&&$2==s{f=1;next} f&&$1=="pool"{print $2; exit} f&&/^rbd:/{f=0}' "$SCFG")
                          

                          MONHOST=$(awk -v s="$STORAGE" '$1=="rbd:"&&$2==s{f=1;next} f&&$1=="monhost"{print $2; exit} f&&/^rbd:/{f=0}' "$SCFG")
                          

                          RBDUSER=$(awk -v s="$STORAGE" '$1=="rbd:"&&$2==s{f=1;next} f&&$1=="username"{print $2; exit} f&&/^rbd:/{f=0}' "$SCFG")
                          

                          KEYRING=$(awk -v s="$STORAGE" '$1=="rbd:"&&$2==s{f=1;next} f&&$1=="keyring"{print $2; exit} f&&/^rbd:/{f=0}' "$SCFG")
                          

                          [[ -n "$POOL" ]] || die "Pool Ceph non trouvé pour le storage '$STORAGE' dans $SCFG."
                          

                          ok "Disque: $POOL/$IMAGE (storage=$STORAGE)"
                          

                          # 4) Lever d'éventuels watchers (locks) RBD
                          

                          msg "Recherche de watchers RBD (locks)"
                          

                          WATCHERS=$(rbd status "$POOL/$IMAGE" 2>/dev/null | awk -F'[= ]' '/watcher=/{print $2}') || true
                          

                          if [[ -n "$WATCHERS" ]]; then
                          

                            warn "Watchers détectés: $WATCHERS → blocklist"
                          

                            while read -r w; do [[ -n "$w" ]] && ceph osd blocklist add "$w" || true; done <<<"$WATCHERS"
                          

                          else
                          

                            ok "Aucun watcher résiduel"
                          

                          fi
                          

                          # 5) Mapper l'image RBD
                          

                          msg "Mapping RBD ($POOL/$IMAGE)"
                          

                          DEV=""
                          

                          DEV=$(rbd map "$POOL/$IMAGE" 2>/dev/null || true)
                          

                          if [[ -z "$DEV" ]]; then
                          

                            warn "Mapping simple échoué → tentative avec credentials de $STORAGE"
                          

                            [[ -n "$MONHOST" && -n "$RBDUSER" && -n "$KEYRING" ]] || die "Credentials incomplets pour $STORAGE"
                          

                            DEV=$(rbd -m "$MONHOST" --id "$RBDUSER" --keyring "$KEYRING" map "$POOL/$IMAGE")
                          

                          fi
                          

                          [[ -b "$DEV" ]] || die "Échec du mapping RBD."
                          

                          ok "Image mappée: $DEV"
                          

                          # 6) Exposer les partitions (partprobe ou kpartx)
                          

                          if command -v kpartx >/dev/null 2>&1; then
                          

                            kpartx -av "$DEV" >/dev/null || true
                          

                          else
                          

                            partprobe "$DEV" || true
                          

                          fi
                          

                          sleep 1
                          

                          # 7) Détecter la racine
                          

                          msg "Détection des partitions/FS"
                          

                          PARTS=( $(ls ${DEV}p* 2>/dev/null || true) )
                          

                          [[ ${#PARTS[@]} -gt 0 ]] || warn "Aucune partition ${DEV}p*; (image sans table de partitions?)"
                          

                          ROOT_DEV=""; EFI_DEV=""; PV_DEV=""
                          

                          if [[ ${#PARTS[@]} -gt 0 ]]; then
                          

                            while read -r line; do
                          

                              dev=$(cut -d: -f1 <<<"$line"); typ=$(sed -nE 's/.*TYPE="([^"]+)".*/\1/p' <<<"$line")
                          

                              case "$typ" in
                          

                                ext4|ext3|ext2) [[ -z "$ROOT_DEV" ]] && ROOT_DEV="$dev" ;;
                          

                                vfat)           [[ -z "$EFI_DEV"  ]] && EFI_DEV="$dev"  ;;
                          

                                LVM2_member)    PV_DEV="$dev" ;;
                          

                              esac
                          

                            done < <(blkid ${DEV}p* 2>/dev/null)
                          

                          fi
                          

                          # 8) Si racine en LVM
                          

                          VG_NAME=""; LV_ROOT=""
                          

                          if [[ -z "$ROOT_DEV" && -n "$PV_DEV" ]]; then
                          

                            msg "Racine probable dans LVM ($PV_DEV)"
                          

                            VG_NAME=$(pvs --config 'devices { global_filter = [ "a|'"$PV_DEV"'|", "r|.*|" ] }' -o vg_name --noheadings 2>/dev/null | awk 'NF{print $1; exit}')
                          

                            [[ -n "$VG_NAME" ]] || die "Impossible de déterminer le VG sur $PV_DEV"
                          

                            msg "Activation du VG $VG_NAME"
                          

                            vgchange --config 'devices { global_filter = [ "a|/dev/rbd.*|", "r|.*|" ] }' -ay "$VG_NAME" >/dev/null
                          

                            # Cherche un LV root non-swap
                          

                            while read -r path name; do
                          

                              [[ "$name" == swap* ]] && continue
                          

                              if [[ "$name" == root* || -z "$LV_ROOT" ]]; then LV_ROOT="$path"; fi
                          

                            done < <(lvs --config 'devices { global_filter = [ "a|/dev/rbd.*|", "r|.*|" ] }' -o lv_path,lv_name "$VG_NAME" --noheadings)
                          

                            [[ -n "$LV_ROOT" ]] || die "LV racine introuvable dans VG $VG_NAME"
                          

                          fi
                          

                          TARGET=${ROOT_DEV:-$LV_ROOT}
                          

                          [[ -n "$TARGET" ]] || die "Aucune cible ext4 trouvée."
                          

                          ok "Cible FS: $TARGET"
                          

                          # 9) e2fsck (ne pas quitter sur code non‑zéro)
                          

                          msg "e2fsck -f -y $TARGET (peut prendre du temps)"
                          

                          set +e
                          

                          E2OUT=$(e2fsck -f -y "$TARGET" 2>&1)
                          

                          E2RC=$?
                          

                          set -e
                          

                          echo "$E2OUT"
                          

                          if (( E2RC & 4 )); then
                          

                            warn "e2fsck a rencontré des erreurs non corrigées (rc=$E2RC)."
                          

                          else
                          

                            ok "e2fsck terminé (rc=$E2RC)."
                          

                          fi
                          

                          # 10) EFI (optionnel)
                          

                          if $DO_EFI && [[ -n "$EFI_DEV" ]]; then
                          

                            msg "fsck.vfat -a $EFI_DEV"
                          

                            fsck.vfat -a "$EFI_DEV" || warn "fsck.vfat a retourné un code non‑zéro"
                          

                          fi
                          

                          # 11) Nettoyage
                          

                          msg "Nettoyage"
                          

                          if [[ -n "$VG_NAME" ]]; then
                          

                            vgchange --config 'devices { global_filter = [ "a|/dev/rbd.*|", "r|.*|" ] }' -an "$VG_NAME" >/dev/null
                          

                          fi
                          

                          if command -v kpartx >/dev/null 2>&1; then kpartx -dv "$DEV" >/dev/null || true; fi
                          

                          rbd unmap "$DEV" >/dev/null || true
                          

                          # 12) Redémarrage de la VM
                          

                          msg "Démarrage de la VM $VMID"
                          

                          qm start "$VMID" >/dev/null && ok "VM $VMID démarrée" || warn "Échec du démarrage VM $VMID (vérifier la console)"
                          

                          exit 0
                        
                      

1. Retirer un serveur de la grappe

2. Réseau full meshed pour CEPH

3. Déménager les réseaux CEPH sur du 10G

4. Réduire la taille d'un disque virtuel

5. Préparer un hyperviseur pour ansible :

adduser ansible
adduser ansible sudo
printf "ansible ALL=(ALL) NOPASSWD:ALL\n" >/etc/sudoers.d/90-ansible && chmod 0440 /etc/sudoers.d/90-ansible