Pratiquer dans un vrai Linux isolé.

Prédire les informations fournies par chaque source avant exécution.

Collecter noyau, distribution, PID 1, architecture et heure UTC.

Séparer faits observés, déductions et informations manquantes.

Produire une fiche d’identité relisible en moins d’une page.

Choisir une unité de laboratoire en échec et figer l’heure du symptôme.

Lire l’état détaillé, les propriétés effectives et le graphe de dépendances.

Extraire uniquement les journaux de la fenêtre utile.

Formuler deux hypothèses et un test discriminant pour chacune.

Écrire correction, critère d’arrêt et rollback avant toute mutation.

Comparer occupation en blocs et en inodes par point de montage.

Identifier les répertoires concentrant fichiers ou volumes sans traverser les autres montages.

Vérifier fichiers supprimés encore ouverts.

Proposer une action réversible adaptée à la vraie ressource épuisée.

Noter identité réelle, groupes et umask.

Tracer les permissions de chaque répertoire parent.

Comparer mode POSIX et ACL effectives.

Tester la correction minimale dans une copie de laboratoire.

Prouver qu’un utilisateur non autorisé reste refusé.

Lister les boots disponibles et identifier le boot défaillant.

Extraire les erreurs et dépendances critiques du boot précédent.

Comparer temps utilisateurspace, noyau et unités lentes.

Vérifier la syntaxe de toute unité suspecte hors ligne.

Écrire une hypothèse qui distingue cause et conséquence.

Identifier l’unité principale et tous ses drop-ins.

Afficher la configuration concaténée dans l’ordre effectif.

Comparer propriétés runtime et texte des fichiers.

Rédiger une surcharge minimale et son retrait, sans l’activer.

Lister variables non définies, expansions non protégées et effets de bord.

Définir contrat d’entrée, sortie et codes retour.

Ajouter mode simulation qui affiche la cible résolue.

Créer tests nominal, entrée vide, chemin inattendu et interruption.

Prouver le nettoyage du répertoire temporaire.

Définir une liste blanche de commandes de lecture.

Ajouter timeout, taille maximale et capture du code retour.

Anonymiser hôtes, utilisateurs et adresses dans une copie.

Produire manifeste JSON et SHA-256 de chaque pièce.

Tester commande absente, timeout et sortie trop grande.

Épingler collections et interpréteur.

Exécuter syntax-check puis check mode avec diff.

Appliquer sur un seul hôte de laboratoire et contrôler le service rendu.

Rejouer et exiger zéro changement inattendu.

Tester le rôle de rollback depuis l’état modifié.

Identifier l’artefact par version et empreinte.

Écrire trois préflights bloquants et leurs messages.

Définir taille du canary, durée d’observation et critères d’arrêt.

Simuler un signal défavorable et vérifier l’arrêt.

Promouvoir seulement après verdict signé par les preuves.

Lire la configuration de résolution réellement utilisée.

Comparer réponse locale et requête directe vers un résolveur de laboratoire.

Observer TTL, chaîne CNAME et autorité.

Tester nom inexistant et timeout sans modifier DNS.

Écrire où se situe la preuve et ce qui reste non testé.

Vérifier adresse et socket d’écoute côté serveur.

Comparer requête loopback, adresse locale et client distant.

Lire routes et règles de filtrage sans les modifier.

Capturer cinq paquets maximum autour d’une tentative.

Identifier la première frontière où le signal disparaît.

Relever MTU sur chaque interface et tunnel.

Tester tailles croissantes avec interdiction de fragmentation.

Comparer tracepath et capture ICMP Packet Too Big.

Relier le seuil observé à l’en-tête d’encapsulation.

Proposer une correction au bon endroit et un test de non-régression.

Figer débit, erreurs et drops de l’interface.

Lire files qdisc et statistiques TCP.

Comparer latence sous charge et hors charge.

Formuler une hypothèse par couche et un test discriminant.

Éviter tout changement de buffer sans baseline.

Lire l’état synthétique puis le détail de l’ensemble.

Comparer identifiants, événements et rôles des membres.

Vérifier qu’aucun filesystem n’est monté depuis la copie de travail.

Écrire prérequis de sauvegarde et critères d’arrêt d’une reconstruction.

Préparer une procédure qui ne confond pas remplacement et ajout.

Cartographier device mapper, volume logique et périphérique physique.

Échantillonner latence, utilité et profondeur de file.

Associer I/O aux processus sans tuer de tâche.

Comparer lecture, écriture et attente CPU.

Écrire ce que `%util` démontre et ne démontre pas.

Écrire RPO, RTO et critères de restauration avant l’essai.

Vérifier manifeste et empreintes de la sauvegarde.

Restaurer vers une cible neuve sans écraser la source.

Comparer contenu, modes, propriétaires et liens.

Lancer un test fonctionnel depuis la cible restaurée.

Inventorier version NFS et options de montage effectives.

Comparer compteurs client et serveur sur une même fenêtre.

Mesurer latence d’une opération fonctionnelle bornée.

Identifier retransmissions et files avant d’augmenter les timeouts.

Proposer un test qui distingue réseau et stockage serveur.

Lister sockets, cœurs, threads et nœuds NUMA.

Associer mémoire disponible et distances NUMA.

Relier PCIe, GPU et interfaces réseau au nœud NUMA.

Dessiner la topologie et noter les informations absentes.

Proposer deux placements à comparer sans inventer de gain.

Formuler une question unique et une métrique principale.

Fixer versions, fréquence, affinité et taille du problème.

Prévoir échauffement puis au moins cinq répétitions.

Conserver chaque résultat, y compris les valeurs défavorables.

Rapporter médiane, dispersion et facteurs de confusion.

Figer la ligne de file et le reason code.

Lire demande complète, partition et contraintes.

Comparer limites d’association et de QoS.

Vérifier ressources réellement disponibles.

Proposer solution minimale sans élargir la QoS globale.

Lire état, raison, auteur et heure du drain.

Comparer configuration Slurm et ressources détectées.

Vérifier dernier heartbeat et journaux bornés.

Identifier jobs présents ou récemment terminés.

Écrire critères précis de retour en service.

Comparer rang de file et facteurs de priorité.

Lire usage de l’association sur la fenêtre pertinente.

Vérifier dépendances, réservations et ressources demandées.

Distinguer estimation du scheduler et garantie.

Rédiger une réponse utilisateur transparente.

Exporter QoS et associations dans un format relisible.

Classer limites par portée et unité TRES.

Rejouer trois demandes synthétiques sans les soumettre.

Identifier effets d’une modification sur les autres associations.

Proposer exception ciblée, durée et date de revue.

Comparer `CfgTRES`, `AllocTRES` et GRES du nœud.

Lire demande et environnement visible dans un job de laboratoire.

Comparer GPU demandé, exposé et comptabilisé.

Vérifier cohérence générique/typée dans accounting.

Documenter tout matériel non réellement testé.

Définir le job, les steps et la fenêtre UTC.

Comparer `squeue`, `sacct` et `scontrol` pendant le cycle de vie.

Lire état de slurmdbd et latence de la base.

Contrôler TRES demandés, alloués et consommés.

Écrire verdict PASS, DELAYED, PARTIAL ou LOST avec preuve.

Figer versions de Slurm, MPI et binaire.

Vérifier allocation et résolution des hôtes.

Lire bibliothèques dynamiques du binaire.

Lancer un programme MPI minimal avant l’application.

Comparer `srun` et launcher MPI selon l’intégration documentée.

Dessiner sockets, cœurs et nœuds NUMA.

Définir deux politiques de placement explicites.

Capturer CPU et mémoire vus par chaque rank.

Répéter le même test au moins cinq fois.

Conclure sur placement avant de conclure sur vitesse.

Lire l’erreur exacte dans l’API des cibles.

Comparer résolution et connexion depuis le serveur Prometheus.

Vérifier certificat, nom attendu et date.

Lire endpoint métriques avec timeout.

Écrire la première frontière fautive et un test après correction.

Nommer le service rendu et le symptôme utilisateur.

Choisir expression, fenêtre `for` et labels stables.

Ajouter propriétaire, résumé, impact et URL de runbook.

Écrire cas normal, pending, firing et récupération.

Tester une absence de données séparément d’une valeur saine.

Mesurer séries actives et croissance par métrique.

Classer labels par nombre de valeurs.

Rechercher identifiant utilisateur, URL ou UUID non borné.

Proposer agrégation ou suppression au point d’instrumentation.

Vérifier que les questions opérationnelles restent répondables.

Définir quatre questions opérationnelles avant les panneaux.

Choisir un SLI par question et son unité.

Ajouter contexte Slurm sans label de job non borné.

Relier chaque alerte à un panneau et un runbook.

Tester affichage normal, saturation, no-data et nœud absent.

Vérifier mappings UID/GID rootless.

Inspecter digest, utilisateur d’image et capabilities.

Appliquer limites CPU/mémoire dans le laboratoire.

Tester écriture sur volume autorisé et refus ailleurs.

Observer processus et cgroup depuis l’hôte.

Vérifier empreinte et définition de l’image.

Lister bind mounts système et utilisateur.

Tester lecture seule puis chemin explicitement inscriptible.

Comparer environnement hôte et conteneur.

Documenter les chemins qui ne doivent jamais être montés.

Remplacer tag flottant de base par digest.

Épingler paquets système et Python avec hashes lorsque disponibles.

Séparer dépendances build et runtime.

Générer SBOM et scanner les secrets du contexte.

Construire deux fois puis expliquer toute différence d’empreinte.

Vérifier périphérique PCIe et module noyau.

Lire version pilote, état GPU et erreurs récentes.

Comparer devices visibles sur l’hôte et dans le job.

Exécuter une requête runtime minimale, pas un benchmark.

Produire verdict AVAILABLE, ALLOCATED, DEGRADED ou BLOCKED.

Figer batch, précision, modèle et versions.

Comparer mémoire au repos, au pic et après itérations.

Associer processus GPU et job Slurm.

Distinguer croissance continue, pic attendu et fragmentation.

Comparer une seule variation contrôlée, par exemple le batch.

Lire matrice de connectivité GPU et affinités CPU.

Associer chaque GPU au nœud NUMA et à la carte réseau.

Définir deux placements de ranks à comparer.

Vérifier visibilité après allocation Slurm.

Écrire les limites d’une topologie sans benchmark réseau.

Exporter la configuration effective de sshd.

Comparer ports, adresses d’écoute et filtrage.

Auditer droits des clés et fichiers de configuration.

Vérifier la syntaxe d’un fichier candidat sans recharger.

Écrire ordre de changement, test et retour arrière.

Décrire l’action métier et les arguments réellement nécessaires.

Repérer shells, variables, wildcards et programmes échappables.

Valider la syntaxe dans un fichier séparé.

Tester commande autorisée et trois commandes refusées.

Vérifier journal d’usage et procédure de retrait.