9 changed files with 22 additions and 1008 deletions
--- a/code/linux/linux-mint/alpi-fiche.sh
+++ b/code/linux/linux-mint/alpi-fiche.sh
@ -1,702 +0,0 @@
 #!/bin/bash
 # Relève la fiche d'une machine, et l'envoie au serveur de l'install party.
 #
 # Ce script vit dans le dépôt du wiki, à côté d'install.sh : il est lu et
 # versionné comme lui, et c'est de là qu'il faut le prendre.
 #
 #     wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/alpi-fiche.sh
 #     chmod +x alpi-fiche.sh
 #     sudo ./alpi-fiche.sh --check     # depuis la session live, avant d'installer
 #     sudo ./alpi-fiche.sh             # après l'installation
 #
 # Sur le réseau de l'install party, plus court :
 #
 #     wget http://10.0.0.1/alpi-fiche.sh && chmod +x alpi-fiche.sh && sudo ./alpi-fiche.sh --check
 #
 # Pourquoi la garder sur le serveur plutôt que sur le poste : trois semaines
 # plus tard, quand quelqu'un rappelle parce que « ça rame », on n'a plus la
 # machine sous la main. Savoir qu'elle a huit ans, quatre gigaoctets de
 # mémoire et un disque mécanique qui commence à réallouer des secteurs répond
 # à la question avant de l'avoir posée.
 #
 # Ce qui est envoyé : le modèle, le processeur, la mémoire, les disques et
 # leur santé, le système installé.
 #
 # Deux de ces champs touchent à la personne, et il faut le dire plutôt que de
 # prétendre le contraire — la première version de cet en-tête annonçait « rien
 # qui touche à la personne », ce qui était faux :
 #
 #   · le NOM DE LA MACHINE, choisi pendant l'installation, contient très
 #     souvent un prénom ;
 #   · l'ADRESSE MATÉRIELLE de la carte réseau identifie durablement l'appareil.
 #
 # Les deux servent : le nom pour s'y retrouver, l'adresse pour rapprocher la
 # fiche du bail DHCP. Mais ils appartiennent à la personne dont on installe
 # l'ordinateur — il faut le lui dire. Ne sont en revanche jamais envoyés : son
 # nom d'utilisateur, ses fichiers, son historique, ni rien de ce qu'elle a
 # installé. Le numéro de série est tronqué à quatre caractères.
 #
 #     alpi-fiche              relève et envoie
 #     alpi-fiche --montrer    relève et affiche, sans rien envoyer
 #     alpi-fiche --check      relève, envoie, et rend un verdict
 #
 # Le mode « --check » est fait pour tourner **depuis la clé USB, avant
 # d'installer** : c'est le seul moment où l'on peut encore renoncer. Un disque
 # qui se déclare défaillant, on ne passe pas une heure à installer dessus — on
 # le dit à son propriétaire et on cherche une autre solution.
 set -u
 # Bash ne compte les caractères — et non les octets — que si la locale le dit.
 # C'est ce qui aligne les colonnes du tableau des disques.
 export LC_ALL="${LC_ALL:-C.UTF-8}"
 # Le temps que met la collecte, en millisecondes.
 #
 # Une machine n'est relevée qu'une fois quand elle n'a pas connu de session
 # live : il n'y a alors pas d'écart entre deux passages à mesurer. Cette durée-
 # ci existe toujours, et elle se compare — elle dit ce que la machine met à
 # s'interroger elle-même : lire le SMART de ses disques, réveiller ceux qui
 # dorment, énumérer ses barrettes. Un plateau qui rame se voit là.
 #
 # On arrête le chronomètre à la fin de la collecte, avant le verdict : celui-ci
 # attend une touche, et l'on mesurerait la personne devant l'écran.
 DEBUT_NS="$(date +%s%N 2>/dev/null || echo 0)"
 # smartctl et dmidecode vivent dans /usr/sbin, que le PATH d'un shell ordinaire
 # ne contient pas toujours — un « command -v » y échouait alors que le binaire
 # était là.
 PATH="$PATH:/usr/sbin:/sbin"
 SERVEUR="${ALPI_SERVEUR:-http://alpicache.lan}"
 MONTRER=0
 CHECK=0
 case "${1:-}" in
    --montrer) MONTRER=1 ;;
    --check)   CHECK=1 ;;
 esac
 if [ -t 1 ]; then
    V=$'\e[32m'; O=$'\e[33m'; R=$'\e[31m'; B=$'\e[1m'; D=$'\e[2m'; Z=$'\e[0m'
 else
    V=""; O=""; R=""; B=""; D=""; Z=""
 fi
 # Ce dont le relevé a besoin, et qu'il installe lui-même plutôt que de rendre
 # un verdict à trous.
 #
 # « état des disques inconnu » n'aide personne : c'est précisément la réponse
 # qu'on était venu chercher. Les deux paquets pèsent moins de deux mégaoctets,
 # ils sont dans le cache, et l'installation prend deux secondes sur le réseau
 # de l'install party. On ne le fait qu'en root, qu'avec apt, et sans rien
 # demander d'autre.
 completer_outils() {
    [ "$(id -u)" = "0" ] || return 0
    command -v apt-get >/dev/null 2>&1 || return 0
    local manquants=""
    command -v smartctl  >/dev/null 2>&1 || manquants="$manquants smartmontools"
    command -v dmidecode >/dev/null 2>&1 || manquants="$manquants dmidecode"
    [ -z "$manquants" ] && return 0
    echo "==> Installation de ce qui manque au relevé :$manquants"
    # Par le cache s'il répond, directement sinon. « -qq » pour ne pas noyer
    # l'écran : ce n'est pas l'objet de la manœuvre.
    local proxy=""
    if command -v wget >/dev/null 2>&1 \
       && wget -q --spider --timeout=3 "$SERVEUR/" 2>/dev/null; then
        proxy="-o Acquire::http::Proxy=http://apt-proxy:3142"
    fi
    DEBIAN_FRONTEND=noninteractive apt-get $proxy -qq -y install $manquants \
        >/dev/null 2>&1 \
        || echo "   (échec — le relevé se fera sans)"
    # Ce qui vient d'arriver est dans /usr/sbin, que le PATH d'un shell
    # ordinaire ne contient pas toujours.
    PATH="$PATH:/usr/sbin:/sbin"
 }
 completer_outils
 lire_dmi() {
    cat "/sys/class/dmi/id/$1" 2>/dev/null | tr -d '\n' | sed 's/^ *//; s/ *$//'
 }
 echapper() {
    # De quoi écrire du JSON sans rien installer : guillemets, antislashs et
    # sauts de ligne, et c'est tout ce qui peut nous arriver ici.
    printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g' | tr -d '\n\r'
 }
 champ() { printf '"%s":"%s"' "$1" "$(echapper "${2:-}")"; }
 # --- La machine ------------------------------------------------------------
 MODELE="$(lire_dmi product_name)"
 MARQUE="$(lire_dmi sys_vendor)"
 SERIE="$(lire_dmi product_serial)"
 # Le numéro de série identifie un objet, pas une personne, mais il n'a rien à
 # faire dans un fichier qu'on partage : on n'en garde que les quatre derniers
 # caractères, assez pour distinguer deux machines du même modèle.
 SERIE="${SERIE: -4}"
 BIOS="$(lire_dmi bios_date)"
 PROCESSEUR="$(awk -F': ' '/^model name/{print $2; exit}' /proc/cpuinfo)"
 COEURS="$(nproc 2>/dev/null || echo '?')"
 MEMOIRE_KO="$(awk '/^MemTotal/{print $2}' /proc/meminfo)"
 SYSTEME=""
 if [ -r /etc/os-release ]; then
    SYSTEME="$(. /etc/os-release; echo "${PRETTY_NAME:-$NAME $VERSION}")"
 fi
 NOYAU="$(uname -r)"
 ARCHITECTURE="$(uname -m)"
 # Sommes-nous sur la clé USB, ou sur le système installé ?
 #
 # La distinction n'est pas cosmétique : les deux relevés répondent à deux
 # questions différentes. Celui de la session live dit « peut-on installer sur
 # cette machine ? » et se fait avant d'effacer quoi que ce soit. Celui d'après
 # dit « qu'avons-nous installé, et sur quoi ». Les garder séparés permet de
 # comparer — un disque qui allait bien le matin et qui se plaint le soir, cela
 # se voit.
 #
 # Le signe qui ne trompe pas est la racine : une session live la monte en
 # overlay au-dessus d'un squashfs, ce qu'aucun système installé ne fait. S'y
 # ajoute « boot=casper » ou « boot=live » sur la ligne de commande du noyau.
 #
 # L'existence de /cdrom ou de /rofs, elle, ne prouve rien : l'installateur de
 # Mint laisse un /cdrom vide derrière lui, et la première version de ce script
 # a donc déclaré « session live » une machine parfaitement installée. On ne les
 # retient que s'ils sont réellement montés.
 MOMENT="post-installation"
 if findmnt -n -o FSTYPE / 2>/dev/null | grep -qE '^(overlay|aufs|squashfs)$' \
   || grep -qE '(^| )boot=(casper|live)( |$)' /proc/cmdline 2>/dev/null \
   || mountpoint -q /rofs 2>/dev/null \
   || { mountpoint -q /cdrom 2>/dev/null \
        && findmnt -n -o FSTYPE /cdrom 2>/dev/null | grep -qE '^(iso9660|squashfs)$'; }; then
    MOMENT="live"
 fi
 # --- La mémoire, barrette par barrette ------------------------------------
 #
 # La question qu'on pose vraiment devant une machine lente : peut-on en
 # ajouter ? Elle demande trois réponses — combien de connecteurs, combien
 # d'occupés, et de quel type. Un slot libre en DDR3 ne se remplit pas avec ce
 # qu'on a dans le tiroir.
 #
 # dmidecode lit cela dans la table du BIOS. Il est présent par défaut sur
 # Debian, Ubuntu et Mint ; s'il manque, on ne prétend rien plutôt que de
 # deviner.
 BARRETTES="["
 SLOTS_TOTAL=0
 SLOTS_PRIS=0
 TYPE_MEMOIRE=""
 VITESSE_MEMOIRE=""
 if command -v dmidecode >/dev/null 2>&1 && [ "$(id -u)" = "0" ]; then
    premier=1
    # Chaque bloc « Memory Device » décrit un connecteur, occupé ou non.
    while IFS= read -r bloc; do
        emplacement="$(printf '%s' "$bloc" | sed -n 's/.*|Locator:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        taille="$(printf '%s' "$bloc" | sed -n 's/.*|Size:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        type_="$(printf '%s' "$bloc" | sed -n 's/.*|Type:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        vitesse="$(printf '%s' "$bloc" | sed -n 's/.*|Speed:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        forme="$(printf '%s' "$bloc" | sed -n 's/.*|Form Factor:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        reference="$(printf '%s' "$bloc" | sed -n 's/.*|Part Number:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        # La vitesse configurée est celle à laquelle la barrette travaille
        # vraiment ; « Speed » n'est que ce dont elle serait capable. L'écart
        # entre les deux explique bien des machines qui « rament » sans raison
        # apparente : une DDR4-3200 bridée à 2133 par la carte mère, ou deux
        # barrettes dépareillées qui s'alignent sur la plus lente.
        vitesse_reelle="$(printf '%s' "$bloc" | sed -n 's/.*|Configured Memory Speed:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        fabricant="$(printf '%s' "$bloc" | sed -n 's/.*|Manufacturer:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        rang="$(printf '%s' "$bloc" | sed -n 's/.*|Rank:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        tension="$(printf '%s' "$bloc" | sed -n 's/.*|Configured Voltage:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        largeur="$(printf '%s' "$bloc" | sed -n 's/.*|Data Width:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        detail="$(printf '%s' "$bloc" | sed -n 's/.*|Type Detail:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        [ -z "$emplacement" ] && continue
        SLOTS_TOTAL=$(( SLOTS_TOTAL + 1 ))
        case "$taille" in
            *"No Module"*|""|"Unknown") taille="" ;;
            *) SLOTS_PRIS=$(( SLOTS_PRIS + 1 ))
               [ -z "$TYPE_MEMOIRE" ] && [ "$type_" != "Unknown" ] && TYPE_MEMOIRE="$type_"
               # Deux barrettes de vitesses différentes s'alignent sur la plus
               # lente : c'est celle-là qu'il faut retenir pour la machine.
               if [ -n "$vitesse_reelle" ] && [ "$vitesse_reelle" != "Unknown" ]; then
                   nombre="${vitesse_reelle%% *}"
                   case "$nombre" in
                       ''|*[!0-9]*) ;;
                       *) if [ -z "$VITESSE_MEMOIRE" ] || [ "$nombre" -lt "$VITESSE_MEMOIRE" ]; then
                              VITESSE_MEMOIRE="$nombre"
                          fi ;;
                   esac
               fi ;;
        esac
        [ "$premier" = 0 ] && BARRETTES="$BARRETTES,"
        premier=0
        BARRETTES="$BARRETTES{$(champ emplacement "$emplacement"),$(champ taille "$taille"),\
 $(champ type "$type_"),$(champ vitesse "$vitesse"),$(champ vitesse_reelle "$vitesse_reelle"),\
 $(champ forme "$forme"),$(champ reference "$reference"),$(champ fabricant "$fabricant"),\
 $(champ rang "$rang"),$(champ tension "$tension"),$(champ largeur "$largeur"),\
 $(champ detail "$detail")}"
    done < <(dmidecode -t memory 2>/dev/null \
             | awk '/^Memory Device$/{bloc=""; dedans=1; next}
                    /^$/{if (dedans && bloc != "") print bloc; dedans=0; bloc=""}
                    dedans {gsub(/^[ \t]+/, ""); bloc = bloc "|" $0}
                    END{if (dedans && bloc != "") print bloc}')
 fi
 BARRETTES="$BARRETTES]"
 TABLE_DISQUES=""
 # Remplir une colonne à la bonne largeur.
 #
 # « printf %-10s » compte les octets, pas les caractères : « mécanique » en
 # pèse dix pour neuf signes, et la colonne suivante glisse d'un cran. Bash,
 # lui, sait compter les caractères quand la locale est en UTF-8 — on lui
 # laisse ce travail, et l'on force la locale plutôt que d'espérer.
 colonne() {
    local texte="$1" largeur="$2" cote="${3:-gauche}" n
    n=${#texte}
    if [ "$n" -gt "$largeur" ]; then
        printf '%s' "${texte:0:$largeur}"
        return
    fi
    local blancs=""
    while [ "$n" -lt "$largeur" ]; do blancs="$blancs "; n=$((n + 1)); done
    if [ "$cote" = droite ]; then printf '%s%s' "$blancs" "$texte"
    else printf '%s%s' "$texte" "$blancs"; fi
 }
 # --- Les disques -----------------------------------------------------------
 #
 # lsblk donne la taille et le type ; le drapeau « rotational » du noyau
 # distingue un disque mécanique d'un SSD sans rien installer. C'est la
 # distinction qui compte : une machine lente avec un disque mécanique de dix
 # ans ne s'arrangera pas avec un système plus léger.
 DISQUES="["
 premier=1
 for chemin in /sys/block/*; do
    nom="$(basename "$chemin")"
    case "$nom" in loop*|ram*|sr*|zram*|dm-*) continue ;; esac
    [ -r "$chemin/size" ] || continue
    taille=$(( $(cat "$chemin/size") * 512 ))
    [ "$taille" -lt 1000000000 ] && continue        # moins d'un Go : pas un disque
    rotatif="$(cat "$chemin/queue/rotational" 2>/dev/null || echo '?')"
    modele="$(cat "$chemin/device/model" 2>/dev/null | sed 's/ *$//')"
    # L'état SMART, s'il est lisible. Sans smartctl on ne prétend rien.
    sante=""
    reallocations=""
    pending=""
    illisibles=""
    heures=""
    usure=""
    ecrit=""
    if command -v smartctl >/dev/null 2>&1; then
        sortie="$(smartctl -H -A "/dev/$nom" 2>/dev/null)"
        sante="$(printf '%s' "$sortie" | grep -iE 'overall-health|SMART Health' \
                 | sed 's/.*: *//' | head -1)"
        reallocations="$(printf '%s' "$sortie" \
                         | awk '/Reallocated_Sector_Ct|Reallocated_Event/{print $10; exit}')"
        # Les secteurs que le disque n'arrive plus à lire. Ils manquaient à la
        # fiche, et c'est ce qui a fait qu'alpicache annonçait « sain » un
        # disque déclaré à remplacer : il ne les avait jamais reçus.
        pending="$(printf '%s' "$sortie" | awk '$2 == "Current_Pending_Sector"{print $10; exit}')"
        illisibles="$(printf '%s' "$sortie" | awk '$2 == "Offline_Uncorrectable"{print $10; exit}')"
        heures="$(printf '%s' "$sortie" | awk '/Power_On_Hours/{print $10; exit}')"
        # L'usure d'un SSD, en pour cent de vie consommée.
        #
        # Un disque mécanique s'use en tournant, un SSD en écrivant : les
        # heures de marche ne disent rien de son état. Chaque constructeur a
        # son attribut, et deux conventions coexistent — les uns comptent ce
        # qui est consommé, les autres ce qui reste. On ramène tout à
        # « consommé », qui est le sens qu'on veut lire. NVMe donne directement
        # « Percentage Used » ; pour les SATA, la colonne VALUE part de 100 et
        # descend.
        usure="$(printf '%s' "$sortie" | awk '/Percentage Used:/{gsub(/[^0-9]/,"",$3); print $3; exit}')"
        if [ -z "$usure" ]; then
            usure="$(printf '%s' "$sortie" | awk '
                /Media_Wearout_Indicator|Wear_Leveling_Count|SSD_Life_Left|Percent_Lifetime_Remain/ {
                    if ($4 ~ /^[0-9]+$/ && $4 <= 100) { print 100 - $4; exit }
                }')"
        fi
        # Ce que le disque a écrit depuis sa mise en service : l'autre façon de
        # juger un SSD, dont les modèles courants tiennent 100 à 600 To.
        ecrit="$(printf '%s' "$sortie" | awk '
            /Total_LBAs_Written|Host_Writes_32MiB|Total_Host_Writes/ {
                if ($10 ~ /^[0-9]+$/) { print $10; exit }
            }
            /Data Units Written:/ { gsub(/[^0-9]/,"",$4); print $4; exit }')"
    fi
    # Les mêmes chiffres, mis en table pour être lus par quelqu'un. Le verdict
    # ne dit que ce qui cloche ; on veut aussi voir ce qui va, et sur quoi le
    # verdict se fonde.
    taille_go="$(awk -v o="$taille" 'BEGIN{printf "%.1f", o/1000000000}' | tr . ,)"
    secteurs="—"
    for valeur in "${pending:-0}" "${illisibles:-0}" "${reallocations:-0}"; do
        case "$valeur" in ''|*[!0-9]*) continue ;; esac
        [ "$valeur" -gt 0 ] && secteurs="!"
    done
    [ "$secteurs" = "!" ] && secteurs="$(printf '%s/%s/%s' \
        "${reallocations:-0}" "${pending:-0}" "${illisibles:-0}")"
    usure_dite="—"
    if [ "$rotatif" = 1 ]; then
        case "$heures" in ''|*[!0-9]*) ;; *)
            usure_dite="$heures h"
            [ "$heures" -ge 8760 ] && usure_dite="$usure_dite ($(( heures / 8760 )),$(( (heures % 8760) * 10 / 8760 )) an)" ;;
        esac
    else
        case "$usure" in ''|*[!0-9]*) ;; *) usure_dite="usé à $usure %" ;; esac
    fi
    TABLE_DISQUES="$TABLE_DISQUES$(
        colonne "$nom" 7; printf ' '
        colonne "${modele:-—}" 20; printf ' '
        colonne "$([ "$rotatif" = 1 ] && echo mécanique || echo SSD)" 10; printf ' '
        colonne "$taille_go Go" 10 droite; printf ' '
        colonne "${sante:-—}" 8; printf ' '
        colonne "$usure_dite" 16; printf ' '
        printf '%s' "$secteurs")"$'\n'
    [ "$premier" = 0 ] && DISQUES="$DISQUES,"
    premier=0
    DISQUES="$DISQUES{$(champ nom "$nom"),$(champ modele "$modele"),\
 \"octets\":$taille,$(champ type "$([ "$rotatif" = 1 ] && echo mécanique || echo SSD)"),\
 $(champ sante "$sante"),$(champ reallocations "$reallocations"),\
 $(champ pending "$pending"),$(champ illisibles "$illisibles"),$(champ heures "$heures"),\
 $(champ usure "$usure"),$(champ ecrit "$ecrit")}"
 done
 DISQUES="$DISQUES]"
 # L'occupation, telle qu'elle est maintenant.
 OCCUPATION="["
 premier=1
 while read -r point taille utilise dispo pourcent; do
    [ "$premier" = 0 ] && OCCUPATION="$OCCUPATION,"
    premier=0
    OCCUPATION="$OCCUPATION{$(champ point "$point"),\"taille\":$taille,\
 \"utilise\":$utilise,$(champ pourcent "$pourcent")}"
 done < <(df -B1 --output=target,size,used,avail,pcent 2>/dev/null \
         | awk 'NR>1 && $2+0 > 1000000000 {print $1, $2, $3, $4, $5}')
 OCCUPATION="$OCCUPATION]"
 # --- Le rapport ------------------------------------------------------------
 # L'adresse matérielle de l'interface par laquelle on sort — celle que le
 # serveur a vue en donnant le bail, donc celle qui permettra de rapprocher
 # cette fiche de la machine servie. « ip -o link » a failli nous donner
 # l'adresse de diffusion, qui est la même pour tout le monde.
 INTERFACE="$(ip -o -4 route show default 2>/dev/null | awk '{print $5; exit}')"
 [ -z "$INTERFACE" ] && INTERFACE="$(ls /sys/class/net 2>/dev/null \
    | grep -v '^lo$' | head -1)"
 MAC="$(cat "/sys/class/net/$INTERFACE/address" 2>/dev/null)"
 RAPPORT="{$(champ machine "$(hostname)"),$(champ mac "$MAC"),\
 $(champ marque "$MARQUE"),$(champ modele "$MODELE"),$(champ serie "$SERIE"),\
 $(champ bios "$BIOS"),$(champ processeur "$PROCESSEUR"),\"coeurs\":${COEURS:-0},\
 \"memoire_ko\":${MEMOIRE_KO:-0},$(champ systeme "$SYSTEME"),$(champ noyau "$NOYAU"),\
 $(champ architecture "$ARCHITECTURE"),$(champ moment "$MOMENT"),\
 $(champ type_memoire "$TYPE_MEMOIRE"),\
 $(champ vitesse_memoire "$VITESSE_MEMOIRE"),\
 \"slots_total\":$SLOTS_TOTAL,\"slots_pris\":$SLOTS_PRIS,\"barrettes\":$BARRETTES,\
 \"disques\":$DISQUES,\"occupation\":$OCCUPATION}"
 DUREE_MS=0
 case "$DEBUT_NS" in
    ''|*[!0-9]*) ;;
    0) ;;
    *) FIN_NS="$(date +%s%N 2>/dev/null || echo 0)"
       case "$FIN_NS" in
           ''|*[!0-9]*|0) ;;
           *) DUREE_MS=$(( (FIN_NS - DEBUT_NS) / 1000000 )) ;;
       esac ;;
 esac
 [ "$DUREE_MS" -lt 0 ] && DUREE_MS=0
 RAPPORT="${RAPPORT%\}},\"duree_releve_ms\":$DUREE_MS}"
 if [ "$MONTRER" = 1 ]; then
    if command -v python3 >/dev/null 2>&1; then
        printf '%s' "$RAPPORT" | python3 -m json.tool 2>/dev/null || printf '%s\n' "$RAPPORT"
    else
        printf '%s\n' "$RAPPORT"
    fi
    exit 0
 fi
 [ "$CHECK" = 1 ] && printf "  %sLa fiche est envoyée à alpicache…%s\n\n" "$D" "$Z"
 echo "Relevé   : $([ "$MOMENT" = live ] && echo "session live, avant installation" \
                    || echo "système installé")"
 echo "Machine  : $MARQUE $MODELE"
 echo "Processeur : $PROCESSEUR ($COEURS cœurs)"
 if [ "$SLOTS_TOTAL" -gt 0 ]; then
    echo "Mémoire  : $(( MEMOIRE_KO / 1024 )) Mo ${TYPE_MEMOIRE:+$TYPE_MEMOIRE }\
 ${VITESSE_MEMOIRE:+à $VITESSE_MEMOIRE MT/s }· \
 $SLOTS_PRIS connecteur(s) occupé(s) sur $SLOTS_TOTAL"
 else
    echo "Mémoire  : $(( MEMOIRE_KO / 1024 )) Mo"
 fi
 echo "Système  : $SYSTEME"
 echo
 MOTIFS=""
 # --- Le verdict ------------------------------------------------------------
 #
 # Trois réponses possibles, et une seule question : peut-on installer sur cette
 # machine ? Les seuils viennent de ce qu'on rencontre en install party, pas
 # d'un idéal — une machine de dix ans avec 4 Go et un disque sain fait très
 # bien l'affaire, et c'est souvent celle qu'on nous apporte.
 # Le verdict sort toujours, live ou non. C'est l'information qu'on est venu
 # chercher : la première version ne le rendait qu'en session live, et le
 # relevé d'après installation défilait sans rien dire de l'état des disques —
 # précisément ce dont on voulait parler au propriétaire.
 [ "$MONTRER" = 1 ] || CHECK=1
 if [ "$CHECK" = 1 ]; then
    GRAVITE=0          # 0 rien à signaler · 1 à surveiller · 2 ne pas installer
    REMARQUES=""
    note() {
        [ "$1" -gt "$GRAVITE" ] && GRAVITE="$1"
        REMARQUES="$REMARQUES$2"$'\n'
        # Le même motif, débarrassé de ses couleurs et de ses retours à la
        # ligne, pour qu'alpicache dise exactement ce qui a été dit ici.
        if [ "$1" -ge 1 ]; then
            # Une note tient sur plusieurs lignes à l'écran ; le motif, lui,
            # est d'un seul tenant — il ira dans une case de tableau.
            nu="$(printf '%s' "$2" | tr '\n' ' ' | sed -e 's/\x1b\[[0-9;]*m//g' \
                                                       -e 's/[[:space:]]\{1,\}/ /g' \
                                                       -e 's/^ *[!?✗·] *//' \
                                                       -e 's/^ *//' -e 's/ *$//')"
            [ -n "$nu" ] && MOTIFS="$MOTIFS$nu"$'\n'
        fi
    }
    # Les disques. C'est pour eux qu'on fait ce contrôle.
    for chemin in /sys/block/*; do
        nom="$(basename "$chemin")"
        case "$nom" in loop*|ram*|sr*|zram*|dm-*) continue ;; esac
        [ -r "$chemin/size" ] || continue
        taille=$(( $(cat "$chemin/size") * 512 ))
        [ "$taille" -lt 1000000000 ] && continue
        if ! command -v smartctl >/dev/null 2>&1; then
            note 1 "  ${O}?${Z} état des disques inconnu — smartmontools n'est pas installé.
      ${D}sudo apt install -y smartmontools${Z} ${D}(il passera par le cache)${Z}"
            break
        fi
        sortie="$(smartctl -H -A "/dev/$nom" 2>/dev/null)"
        if printf '%s' "$sortie" | grep -qiE 'overall-health.*(FAILED|FAILING)'; then
            note 2 "  ${R}✗${Z} ${B}/dev/$nom se déclare défaillant${Z} — ne pas installer dessus."
        fi
        # Les trois attributs ne disent pas la même chose, et les confondre
        # revient à sous-estimer les deux qui comptent.
        #
        #   Reallocated_Sector_Ct   des secteurs déjà remplacés par la réserve
        #                           du disque. Quelques-uns sont de l'usure
        #                           ordinaire ; c'est leur nombre qui parle.
        #   Current_Pending_Sector  des secteurs que le disque n'arrive plus à
        #                           lire et n'a pas encore pu déplacer. Ce
        #                           qu'ils contenaient est en train d'être
        #                           perdu. Un seul suffit à s'inquiéter.
        #   Offline_Uncorrectable   des secteurs définitivement illisibles.
        #
        # Les deux derniers ne sont pas de l'usure mais une panne en cours :
        # on ne les mesure pas à la même aune que le premier.
        for attribut in Reallocated_Sector_Ct Current_Pending_Sector Offline_Uncorrectable; do
            valeur="$(printf '%s' "$sortie" | awk -v a="$attribut" '$2 == a {print $10; exit}')"
            case "$valeur" in ''|*[!0-9]*) continue ;; esac
            [ "$valeur" = "0" ] && continue
            case "$attribut" in
                Reallocated_Sector_Ct)
                    libelle="secteur(s) déjà remplacé(s)"
                    if [ "$valeur" -ge 50 ]; then
                        note 2 "  ${R}✗${Z} /dev/$nom : ${B}$valeur $libelle${Z} — disque à remplacer."
                    else
                        note 1 "  ${O}!${Z} /dev/$nom : $valeur $libelle — à surveiller."
                    fi ;;
                Current_Pending_Sector)
                    note 2 "  ${R}✗${Z} /dev/$nom : ${B}$valeur secteur(s) illisible(s)${Z} en attente.
      ${R}Ce ne sont pas des secteurs usés mais des données que le disque
      n'arrive plus à relire : le disque est en train de lâcher.${Z}
      ${D}Sauvegarder ce qui doit l'être avant toute autre chose, et
      ne rien installer dessus — l'installation ne tiendrait pas.${Z}" ;;
                Offline_Uncorrectable)
                    note 2 "  ${R}✗${Z} /dev/$nom : ${B}$valeur secteur(s) définitivement perdu(s)${Z}.
      ${R}Le disque a renoncé à les relire. À remplacer.${Z}" ;;
            esac
        done
        heures="$(printf '%s' "$sortie" | awk '/Power_On_Hours/{print $10; exit}')"
        rotatif="$(cat "$chemin/queue/rotational" 2>/dev/null)"
        # L'usure, recalculée ici : cette boucle est distincte de celle du
        # relevé et ne voit pas ses variables.
        usure="$(printf '%s' "$sortie" | awk '/Percentage Used:/{gsub(/[^0-9]/,"",$3); print $3; exit}')"
        if [ -z "$usure" ]; then
            usure="$(printf '%s' "$sortie" | awk '
                /Media_Wearout_Indicator|Wear_Leveling_Count|SSD_Life_Left|Percent_Lifetime_Remain/ {
                    if ($4 ~ /^[0-9]+$/ && $4 <= 100) { print 100 - $4; exit }
                }')"
        fi
        # Un disque mécanique se signale toujours, et pas seulement quand il
        # est vieux. C'est le premier frein d'une machine par ailleurs
        # correcte : remplacer un plateau par un SSD fait plus pour elle que
        # n'importe quel réglage, et c'est le genre de conseil qu'on donne
        # pendant qu'on a la machine ouverte devant soi.
        # Les heures de marche, dites en heures et en années de fonctionnement.
        # « 477 j 15 h » se lit mal : on croit à un disque épuisé alors que
        # c'est une année et quelques mois de marche, ce qui est peu.
        marche=""
        case "$heures" in
            ''|*[!0-9]*) ;;
            *) marche="$heures h"
               if [ "$heures" -ge 8760 ]; then
                   marche="$marche, soit $(( heures / 8760 )),$(( (heures % 8760) * 10 / 8760 )) an de marche"
               fi ;;
        esac
        if [ "$rotatif" = "1" ]; then
            # Un disque mécanique se fatigue en tournant. Les constructeurs
            # annoncent 300 000 à 600 000 heures de MTBF, mais le retour du
            # terrain est plus sobre : au-delà de 30 000 heures — trois ans et
            # demi de marche continue — les pannes deviennent sensiblement plus
            # fréquentes, et à 45 000 on est dans le sursis.
            gravite_disque=1
            supplement=""
            case "$heures" in
                ''|*[!0-9]*) ;;
                *) if [ "$heures" -ge 45000 ]; then
                       gravite_disque=2
                       supplement="
      ${R}Au-delà de 45 000 heures : sauvegarder avant toute chose.${Z}"
                   elif [ "$heures" -ge 30000 ]; then
                       supplement="
      ${O}Plus de 30 000 heures de marche : il a fait son temps.${Z}"
                   fi ;;
            esac
            note "$gravite_disque" "  ${O}!${Z} /dev/$nom est un ${B}disque mécanique${Z}${marche:+ · $marche}.
      ${D}Le remplacer par un SSD ferait plus pour cette machine que
      tout le reste réuni — démarrage, ouverture des programmes, réactivité.${Z}$supplement"
        else
            # Un SSD ne s'use pas en tournant mais en écrivant. Les heures de
            # marche ne disent rien de son état : c'est l'usure qu'on regarde.
            case "$usure" in
                ''|*[!0-9]*)
                    [ -n "$marche" ] && note 0 "  ${V}·${Z} /dev/$nom est un SSD · $marche.
      ${D}Usure non déclarée par ce modèle.${Z}" ;;
                *) if [ "$usure" -ge 90 ]; then
                       note 2 "  ${R}✗${Z} /dev/$nom : SSD usé à ${B}${usure} %${Z} — il approche de sa fin.
      ${R}Sauvegarder, et prévoir son remplacement.${Z}"
                   elif [ "$usure" -ge 70 ]; then
                       note 1 "  ${O}!${Z} /dev/$nom : SSD usé à ${usure} %${marche:+ · $marche}.
      ${D}Encore utilisable, mais il faudra y penser.${Z}"
                   else
                       note 0 "  ${V}·${Z} /dev/$nom : SSD usé à ${usure} % seulement${marche:+ · $marche}."
                   fi ;;
            esac
        fi
        if [ "$taille" -lt 32000000000 ]; then
            note 1 "  ${O}!${Z} /dev/$nom ne fait que $(( taille / 1000000000 )) Go — c'est juste."
        fi
    done
    # La mémoire, le processeur.
    MEMOIRE_MO=$(( MEMOIRE_KO / 1024 ))
    if [ "$MEMOIRE_MO" -lt 2048 ]; then
        note 2 "  ${R}✗${Z} ${B}${MEMOIRE_MO} Mo de mémoire${Z} — trop peu pour Mint.
      ${D}Envisager une version légère, ou ajouter de la mémoire.${Z}"
    elif [ "$MEMOIRE_MO" -lt 4096 ]; then
        libres=$(( SLOTS_TOTAL - SLOTS_PRIS ))
        note 1 "  ${O}!${Z} ${MEMOIRE_MO} Mo de mémoire — Mint tournera, mais sans aisance.$(
            [ "$libres" -gt 0 ] && printf '\n      %s' "${D}$libres connecteur(s) ${TYPE_MEMOIRE} libre(s) : la machine est extensible.${Z}")"
    fi
    if [ "$ARCHITECTURE" != "x86_64" ] && [ "$ARCHITECTURE" != "aarch64" ]; then
        note 2 "  ${R}✗${Z} processeur ${ARCHITECTURE} — les versions 64 bits ne s'installeront pas."
    fi
    echo
    case "$GRAVITE" in
        0) printf "  %s%s BON POUR L'INSTALLATION %s\n" "$B$V" "✓" "$Z" ;;
        1) printf "  %s%s INSTALLATION POSSIBLE, AVEC DES RÉSERVES %s\n" "$B$O" "!" "$Z" ;;
        2) printf "  %s%s NE PAS INSTALLER EN L'ÉTAT %s\n" "$B$R" "✗" "$Z" ;;
    esac
    echo
    if [ -n "$TABLE_DISQUES" ]; then
        printf '  %s' "$D"
        colonne "Disque" 7; printf ' '
        colonne "Modèle" 20; printf ' '
        colonne "Type" 10; printf ' '
        colonne "Taille" 10 droite; printf ' '
        colonne "SMART" 8; printf ' '
        colonne "Marche / usure" 16; printf ' '
        printf 'Secteurs R/P/I%s\n' "$Z"
        printf '%s' "$TABLE_DISQUES" | sed "s/^/  /"
        printf "  %sR : remplacés · P : illisibles en attente · I : perdus%s\n" "$D" "$Z"
        echo
    fi
    [ -n "$REMARQUES" ] && printf "%s\n" "$REMARQUES"
    # Une pause, sans quoi tout cela défile et personne ne le lit. Sa durée
    # suit la gravité, et l'on n'attend jamais indéfiniment : le script tourne
    # aussi sans personne devant l'écran, appelé par install.sh.
    if [ -t 0 ]; then
        case "$GRAVITE" in
            2) printf "  %sEn parler au propriétaire AVANT de toucher à quoi que ce soit.%s\n" "$D" "$Z"
               printf "  %sEntrée pour continuer malgré tout%s " "$B" "$Z"
               read -r -t "${ALPI_PAUSE_ALERTE:-120}" _ || echo ;;
            1) printf "  %sEntrée pour continuer (reprise automatique dans %ss)%s " \
                      "$D" "${ALPI_PAUSE:-20}" "$Z"
               read -r -t "${ALPI_PAUSE:-20}" _ || echo ;;
            *) sleep "${ALPI_PAUSE_OK:-3}" ;;
        esac
        echo
    fi
 fi
 # Ce que l'on vient de dire à la personne part avec la fiche.
 #
 # Sans cela, alpicache rejugeait à partir des seuls champs reçus — et ne voyait
 # pas les secteurs en attente, qui ne lui étaient pas envoyés. Il affichait
 # « sain » un disque que ce script venait de déclarer à remplacer. Deux juges,
 # deux verdicts : il n'y en a plus qu'un, et c'est celui-ci.
 VERDICT="ok"
 case "${GRAVITE:-0}" in
    2) VERDICT="alerte" ;;
    1) VERDICT="attention" ;;
 esac
 MOTIFS_JSON="["
 premier=1
 while IFS= read -r ligne; do
    [ -n "$ligne" ] || continue
    [ "$premier" = 0 ] && MOTIFS_JSON="$MOTIFS_JSON,"
    premier=0
    MOTIFS_JSON="$MOTIFS_JSON$(printf '%s' "$ligne" \
        | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' -e 's/^/"/' -e 's/$/"/')"
 done <<< "${MOTIFS:-}"
 MOTIFS_JSON="$MOTIFS_JSON]"
 RAPPORT="${RAPPORT%\}},$(champ verdict "$VERDICT"),\"motifs\":$MOTIFS_JSON}"
 if command -v curl >/dev/null 2>&1; then
    reponse="$(printf '%s' "$RAPPORT" | curl -s --max-time 15 \
               -H 'Content-Type: application/json' --data-binary @- "$SERVEUR/fiche")"
 elif command -v wget >/dev/null 2>&1; then
    reponse="$(printf '%s' "$RAPPORT" | wget -qO- --timeout=15 \
               --header='Content-Type: application/json' --post-file=- "$SERVEUR/fiche")"
 else
    echo "Ni curl ni wget : la fiche n'a pas pu être envoyée." >&2
    exit 1
 fi
 if [ -n "$reponse" ]; then
    echo "$reponse"
 else
    echo "Le serveur n'a pas répondu — la fiche n'est pas enregistrée." >&2
    exit 1
 fi
--- a/code/linux/linux-mint/install.sh
+++ b/code/linux/linux-mint/install.sh
@ -1,27 +1,5 @@
 #!/bin/bash
 ##################################################
 # Fiche matérielle pour le serveur de l'install party
 #
 # Placée au début, et non à la fin : si un disque faiblit, autant le savoir
 # avant d'avoir passé une heure à installer dessus — c'est le moment où l'on
 # peut encore en parler à son propriétaire. Et si l'installation s'arrête en
 # route, on a tout de même la fiche.
 #
 # Le relevé est le script voisin du dépôt, lu et versionné comme celui-ci :
 # rien n'est téléchargé ni exécuté depuis le réseau. S'il n'est pas là, on
 # passe — la machine d'un particulier qui rejoue ce script chez elle ne doit
 # rien avoir à faire de tout ceci.
 #
 # C'est la seconde passe, celle que « sudo » relance, qui l'exécute :
 # dmidecode et smartctl demandent les droits d'administration.
 ##################################################
 if [ "$(id -u)" = "0" ] && [ -x "$(dirname "$0")/alpi-fiche.sh" ]; then
    "$(dirname "$0")/alpi-fiche.sh" || true
 fi
 # Script de post-installation pour Linux Mint 22.3
 # testé le 25/03/2026
 #
--- a/docs/alpinux/install-party.md
+++ b/docs/alpinux/install-party.md
@ -58,7 +58,6 @@ Lors de nos **Install Party**, les bénévoles d'**Alpinux** installent Linux av
 ## 🧰 Après l'installation
 - 🩹 [**Trousse de premiers secours Linux Mint**](../guides/linux-mint-trousse.md) — les réflexes utiles des premiers jours.
 - 🖧 [**Le serveur qu'on emporte**](../technique/serveur-install-party.md) — le réseau de la salle, le cache de paquets, et ce qu'un bénévole doit en savoir.
 - 🗣️ [**Ateliers et rencontres**](evenements.md) — pour progresser et échanger avec la communauté.
 ---
--- a/docs/deploiement.md
+++ b/docs/deploiement.md
@ -1,23 +0,0 @@
 # wiki.alpinux.org
 Documentation publique Alpinux — MkDocs Material.
 ## Déploiement
 ```bash
 cd org.alpinux.owni/wiki
 mkdocs build --strict
 rsync -rlcz --delete site/ alpinux.org:/var/www/wiki.alpinux.org/web/
 ```
 ## Développement local
 ```bash
 pip install mkdocs-material
 mkdocs serve    # http://localhost:8000
 ```
 ## Notes
 - Pas de service systemd — site statique servi directement par Apache
 - Les docs publiques sont dans `wiki/docs/technique/`
--- a/docs/guides/linux-mint-depuis-windows.md
+++ b/docs/guides/linux-mint-depuis-windows.md
@ -104,6 +104,10 @@ Clic droit sur **Démarrer** → *Terminal (administrateur)*, puis :
 powercfg /hibernate off
 ```
 !!! tip "Le dernier arrêt de Windows"
    Au moment d'éteindre Windows pour insérer la clé USB, maintenez **Maj (Shift)**
    enfoncée en cliquant sur *Démarrer → Arrêter*. Cela force un arrêt complet.
 ### Gestion de l'alimentation de la carte Wi-Fi
 Certaines cartes Wi-Fi (puces Realtek ou Broadcom notamment) restent dans l'état de basse
@ -184,8 +188,6 @@ Linux. Il faut le basculer sur **AHCI**, dans la section *Storage*, *SATA Config
    conserver Windows, faites le changement avec un bénévole. Si Windows est de toute
    façon remplacé, la bascule est sans conséquence.
 ---
 ## 2. Préparer son support d'installation
@ -244,11 +246,8 @@ Avec [Ventoy](ventoy.md), la préparation tient en un copier-coller :
 ### Branchements
 - Insérez la clé Ventoy dans un **port USB de la machine**, en évitant les hubs.
- **Branchez un câble Ethernet.** Le script install.sh de Alpinux effectue des tests.
+- **Branchez un câble Ethernet.** Mint pourra télécharger mises à jour, codecs et paquets
-
+  de langue pendant l'installation — cela évite beaucoup de réglages ensuite.
 !!! tip "Le dernier arrêt de Windows - Comment arrêter Windows pour démarrer sur la clé USB"
    Au moment d'éteindre Windows pour insérer la clé USB, maintenez **Maj (Shift)**
    enfoncée en cliquant sur *Démarrer → Arrêter*. Cela force un arrêt complet.
 ### Accéder au menu de démarrage
@ -342,27 +341,18 @@ fatigué. On ne le découvre pas au milieu du partitionnement.
 En session live, taper les commandes une à une est fastidieux. Un script d'Alpinux fait
 l'inventaire et rend un verdict :
 **Sur le réseau de l'install party**, où les scripts sont servis par
 [le serveur qu'Alpinux emporte](../technique/serveur-install-party.md) :
 ```bash
-wget http://alpicache.lan/verif-disque.sh && chmod +x verif-disque.sh && ./verif-disque.sh
+wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/verif-disque.sh
 ```
 !!! tip "Si le nom ne répond pas"
    Le serveur répond aussi à `alpicache`, `apt-proxy` et `10.0.0.1` — cette
    dernière adresse fonctionne même quand la résolution de noms n'est pas encore
    en place :
    `wget http://10.0.0.1/verif-disque.sh`
 **Ailleurs, depuis Internet :**
 ```bash
 wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/verif-disque.sh
 chmod +x verif-disque.sh
 ./verif-disque.sh
 ```
 Sur le réseau de l'install party, plus court :
 ```bash
 wget http://10.0.0.1/verif-disque.sh && chmod +x verif-disque.sh && ./verif-disque.sh
 ```
 Il **ne modifie rien** — il lit, il affiche, il conseille. Il demande le mot de passe pour
 les vérifications qui le nécessitent, puis passe en revue :
@ -378,40 +368,6 @@ les vérifications qui le nécessitent, puis passe en revue :
 Il finit par deux listes : *à régler avant d'installer*, et *à savoir*.
 ### Relever la fiche de la machine
 En install party, un second script complète l'état des lieux : il relève la **fiche
 matérielle** — modèle, processeur, mémoire et ses connecteurs, disques et leur santé —
 et l'envoie au serveur de l'association.
 ```bash
 wget http://alpicache.lan/alpi-fiche.sh && chmod +x alpi-fiche.sh && sudo ./alpi-fiche.sh --check
 ```
 Hors réseau de l'install party, il se prend sur Internet :
 ```bash
 wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/alpi-fiche.sh
 ```
 Il n'aura alors aucun serveur à qui remettre la fiche : il l'affiche, et c'est tout.
 Lancé depuis la session live, il rend en plus un verdict en trois états : **bon pour
 l'installation**, **possible avec des réserves**, ou **ne pas installer en l'état** — un
 disque qui se déclare défaillant, des secteurs réalloués, moins de 2 Go de mémoire, un
 processeur 32 bits. C'est le dernier moment où l'on peut encore renoncer et en parler au
 propriétaire.
 Le même script, relancé après l'installation (sans `--check`), enregistre ce qui a
 finalement été installé. Les deux relevés se comparent : un disque qui allait bien le
 matin et se plaint le soir, cela se voit.
 !!! warning "Dites-le à la personne dont vous installez la machine"
    La fiche part sur le réseau local, vers le serveur de l'association, et n'en sort
    pas. Elle ne contient ni fichiers, ni historique, ni nom d'utilisateur — mais elle
    contient le **nom de la machine**, souvent un prénom, et l'**adresse matérielle** de
    la carte réseau. C'est son ordinateur : cela se demande, cela ne se suppose pas.
 !!! danger "BitLocker : ne touchez à rien"
    Si le script annonce une partition chiffrée par BitLocker, **arrêtez-vous là**. Le
    chiffrement doit être suspendu depuis Windows — *Paramètres → Confidentialité et
@ -612,34 +568,25 @@ Le système est installé ; quelques réglages le rendent réellement utilisable
 ### Le script de post-installation Alpinux
 Il automatise ce qui manque presque toujours après une installation standard. Ouvrez un
-terminal (`Ctrl + Alt + T`) et récupérez-le — **sur le réseau local de l'Install Party**,
+terminal (`Ctrl + Alt + T`) et récupérez-le — **sur le réseau local de l'Install Party** :
 où [le serveur d'Alpinux](../technique/serveur-install-party.md) le sert et met en cache
 tout ce que la machine téléchargera ensuite :
 ```bash
-wget http://alpicache.lan/install.sh http://alpicache.lan/alpi-fiche.sh
+wget http://10.0.0.1/install.sh
 ```
 **ou depuis Internet :**
 ```bash
-wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/install.sh \
+wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/install.sh
     https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/alpi-fiche.sh
 ```
 Puis, dans les deux cas :
 ```bash
-chmod +x install.sh alpi-fiche.sh
+chmod +x install.sh
 ./install.sh
 ```
 !!! note "Pourquoi deux fichiers"
    `install.sh` commence par relever la fiche matérielle, et il ne le fait **que s'il
    trouve `alpi-fiche.sh` à côté de lui** — il ne va rien chercher sur le réseau de
    lui-même. Téléchargé seul, il s'installera très bien, simplement sans relevé. En
    install party, prenez les deux.
 Le mot de passe est demandé au passage (`alpinux73` en Install Party) : les caractères ne
 s'affichent pas, c'est normal.
--- a/docs/guides/utiliser-linux-mint.md
+++ b/docs/guides/utiliser-linux-mint.md
@ -109,31 +109,16 @@ Les **Préférences** s'organisent en trois onglets :
 !!! tip "Le piège du `/boot` plein"
    Les anciens noyaux s'accumulent et finissent par saturer la partition de démarrage,
    ce qui bloque toute nouvelle mise à jour. L'onglet *Automatisation* permet de
-    programmer leur suppression ; à défaut, passez de temps en temps par
+    programmer leur suppression ; à défaut, retirez-les de temps en temps depuis
-    **Affichage → Noyaux Linux**, qui les liste et permet de retirer les plus anciens.
+    l'*Analyseur de noyaux* du gestionnaire.
 !!! warning "Changer de noyau n'est pas anodin"
    La même fenêtre *Noyaux Linux* s'ouvre sur un avertissement qu'il vaut la peine de
    lire : un noyau plus récent peut faire disparaître le Wi-Fi, l'accélération graphique,
    ou donner un écran noir au démarrage — surtout avec des pilotes propriétaires.
    La sortie de secours tient en quatre gestes, à connaître **avant** d'en installer un :
    redémarrer, maintenir **Maj** pour afficher le menu GRUB, choisir *Advanced options*
    puis un noyau antérieur, et désinstaller le plus récent une fois revenu.
 ### Activer le pare-feu
 Le pare-feu est installé, mais **désactivé par défaut**. Pour un ordinateur portable qui
 se connecte à des réseaux publics, il vaut mieux l'allumer :
-**Paramètres du système → Pare-feu** (famille *Administration*). L'ouverture demande votre
+**Paramètres du système → Pare-feu** (famille *Administration*), puis basculez **État** sur *Activé*. Le profil *Public* convient :
-mot de passe, puis il suffit de basculer **État** sur *Activé*.
+il bloque les connexions entrantes et laisse passer tout ce que vous initiez.
 Le profil proposé par défaut, **Domestique**, convient : les deux lignes en dessous
 annoncent la règle appliquée — *Entrant : Refuser*, *Sortant : Autoriser*. Autrement dit,
 rien ne rentre sans y avoir été invité, tout ce que vous lancez sort normalement. Les
 profils *Bureau* et *Public* servent à mémoriser d'autres jeux de règles ; sans besoin
 précis, n'y touchez pas.
 ### Vérifier ses pilotes
--- a/docs/technique/serveur-install-party.md
+++ b/docs/technique/serveur-install-party.md
@ -1,169 +0,0 @@
 ---
 description: Le serveur qu'Alpinux emporte en install party — partage de connexion, réseau local, cache de paquets APT, page de santé, et ce qu'un bénévole doit en savoir sur place.
 ---
 # Le serveur qu'on emporte en install party
 Quinze ordinateurs qui s'installent le même matin, c'est quinze fois les mêmes
 cinq cents mégaoctets tirés par la ligne de la salle — quand il y en a une. Alpinux
 apporte donc sa propre machine, **alpicache**, qui partage l'accès à Internet, sert un
 réseau local aux postes en cours d'installation, et **garde en cache les paquets déjà
 téléchargés**.
 !!! note "Pour qui est cette page"
    Pour les bénévoles qui installent, et pour qui prépare la salle. La configuration
    complète de la machine — interfaces, services, dépannage détaillé — vit dans son
    propre dépôt, `alpinux.alpicache`, et non ici.
 ---
 ## Le réseau de la salle
 ```mermaid
 flowchart LR
  A[Prise murale<br/>ou box de la salle] --> B[alpicache<br/>10.0.0.1]
  B --> C[Switch]
  C --> D[Poste 1]
  C --> E[Poste 2]
  C --> F[Poste n]
 ```
 La machine tient les deux bouts : d'un côté elle demande un accès à la salle, de l'autre
 elle distribue un réseau en **10.0.0.x** aux postes branchés sur le switch. Les rôles ne
 sont pas figés à l'avance : elle désigne comme sortie la première prise où on lui répond,
 et sert le réseau local sur l'autre.
 !!! warning "Les postes se branchent sur le switch, jamais sur la box"
    Un poste branché directement sur la box de la salle reçoit une adresse de la salle :
    il ne voit plus le cache, ne trouve plus les scripts, et fait tomber les compteurs à
    zéro. C'est l'erreur la plus fréquente, et elle ne se voit pas tout de suite.
 ---
 ## Ce que la machine offre, une fois branchée
 | Adresse | À quoi ça sert |
 | --- | --- |
 | **<http://alpicache.lan/>** | La page de santé : réseau, disques, machines servies, cache |
 | **`http://apt-proxy:3142`** | Le cache de paquets, à déclarer comme mandataire |
 | **`http://10.0.0.1/`** | Les scripts d'Alpinux, servis sur place — dont `verif-disque.sh` et `install.sh` |
 La page de santé se rafraîchit seule ; c'est le tableau de bord de la journée. Quatre
 cartes à surveiller :
 | Carte | Ce qu'on veut y voir |
 | --- | --- |
 | **Réseau** | une sortie *et* un réseau local nommés, « Internet joignable » |
 | **Disques** | le disque du cache présent, avec de la place |
 | **Machines servies** | le nombre grandit à mesure que les postes arrivent |
 | **Cache de paquets** | « Économisé » qui monte au fil de la matinée |
 **« Machines servies » qui reste à zéro** alors que des postes sont branchés, c'est le
 signe que le réseau local ne distribue pas d'adresses : prévenez la personne qui tient la
 machine plutôt que de chercher sur le poste du participant.
 ---
 ## Faire passer une installation par le cache
 C'est là que tout se joue, et le geste n'est pas le même selon le système.
 ### Debian
 L'installateur demande un mandataire à l'écran **« Configurer le miroir de l'archive
 Debian »**. Saisissez-y :
 ```
 http://apt-proxy:3142
 ```
 C'est **le seul moment** où on peut le faire, et c'est celui qui compte : toute
 l'installation passe alors par le cache.
 ### Linux Mint et Ubuntu
 Leur installateur ne demande pas de mandataire : l'installation elle-même sortira sur
 Internet. Le gain arrive juste après — sur les mises à jour et les logiciels ajoutés,
 c'est-à-dire sur l'essentiel du volume.
 Une fois la machine redémarrée sur son nouveau système :
 ```bash
 sudo apt install auto-apt-proxy
 ```
 Ce paquet cherche un cache sur le réseau local et s'en sert quand il en trouve un — sans
 rien à configurer, et sans gêner la machine une fois rentrée chez son propriétaire.
 !!! tip "Le script de post-installation le fait déjà"
    Le [script d'Alpinux](../guides/linux-mint-depuis-windows.md#le-script-de-post-installation-alpinux)
    installe `auto-apt-proxy` parmi ses réglages : si vous le lancez, c'est fait.
 ---
 ## Ce qui coince, et la parade
 **La salle n'a pas de réseau.** Un téléphone Android en partage de connexion USB fait
 l'affaire : branché sur la machine, il devient la sortie. Prévoyez le câble.
 **Le disque du cache n'est pas vu.** Il doit être branché **avant** d'allumer la machine.
 Après coup, le cache démarre sans rien dire et ne garde rien — la carte *Disques* de la
 page de santé le montre tout de suite.
 **Un poste n'obtient pas d'adresse.** Vérifiez d'abord le câble et le switch, puis la
 carte *Machines servies*. Une adresse en `169.254.x.x` signifie que le poste n'a reçu
 aucune réponse : il s'en est inventé une.
 **`apt` renvoie des « 503 Connection closed » en série.** Le cache accepte la requête mais
 ne sait pas où aller la chercher — c'est arrivé le 24/09/2026, et une installation Mint
 s'y est arrêtée. Le piège est qu'**interroger le cache directement répond parfaitement** :
 les deux chemins ne suivent pas la même route à l'intérieur du serveur. Ne cherchez donc
 pas sur la machine du participant : prévenez la personne qui tient le serveur.
 ---
 ## Pour préparer une install party
 La veille, la machine s'allume chez quelqu'un, sur une ligne rapide, et l'on garnit le
 cache avec ce qu'on va installer — si la version de Mint a changé depuis la dernière
 sortie, autant la tirer maintenant.
 !!! warning "Le cache ne sert que ce qu'il connaît"
    Le pré-chargement vise des versions nommées, et une version absente de la liste ne
    profite à personne. Le 24/09/2026, la première Mint 22.3 de la soirée a tiré **1,3 Go
    d'Internet pour 82 Mo servis par le cache** : le pré-chargeur couvrait encore les
    versions précédentes.
    Avant chaque sortie, vérifiez donc que la liste des versions pré-chargées correspond à
    celle que vous allez réellement installer. C'est par le **nom de code** que le
    pré-chargement les désigne, et un décalage d'un cran suffit à garnir le cache de la
    mauvaise version :
    | Version | Nom de code |
    |---|---|
    | Mint 22 | `wilma` |
    | Mint 22.1 | `xia` |
    | Mint 22.2 | `zara` |
    | Mint 22.3 | `zena` |
    Pour mémoire, la série précédente : `vanessa` (21), `vera` (21.1), `victoria` (21.2),
    `virginia` (21.3).
 Sur place, l'ordre de branchement n'est pas une superstition : le disque externe d'abord,
 puis le câble Internet **seul**, puis la machine, et seulement ensuite le switch et les
 postes. Brancher la sortie seule d'abord, c'est ôter à la machine toute occasion de se
 tromper de rôle.
 La procédure complète — ce qu'on emporte, les vérifications, le dépannage, la fiche à
 cocher pour chaque participant et l'affiche à scotcher près du switch — est dans le dépôt
 `alpinux.alpicache`. Demandez-la à un membre du bureau avant une sortie.
 ---
 ## Voir aussi
 - [Install Party](../alpinux/install-party.md) — les dates, et comment y participer
 - [Installer Linux Mint depuis Windows](../guides/linux-mint-depuis-windows.md) — le guide
  suivi sur place
 - [Préparation d'un serveur Debian 13](serveur-debian-13.md) — pour la machine, la base
  système est la même
--- a/mkdocs.yml
+++ b/mkdocs.yml
@ -119,7 +119,6 @@ nav:
    - technique/matrix.md
    - technique/arduino-ide.md
    - technique/serveur-debian-13.md
    - technique/serveur-install-party.md
    - technique/bigbluebutton.md
    - technique/ateliers.md
  - Communication: