ssh votre_login@adresse_du_cluster.fr
Vous vous demandez ce qu’est un cluster de calcul ? Ce sont des serveurs (ordinateurs) connectés entre eux pour effectuer des tâches qui seraient trop longues ou trop gourmandes pour votre ordinateur personnel. Ce guide vous accompagnera pas à pas pour comprendre les bases et lancer votre premier "job" (tâche de calcul) en utilisant un outil appelé SLURM.
Votre ordinateur a ses limites : Pour certaines analyses scientifiques, simulations, ou traitements de données, votre ordinateur portable ou de bureau peut manquer de puissance de calcul (il est trop lent), de mémoire vive (RAM, sa mémoire à court terme) ou d’espace de stockage.
La puissance du nombre : Un cluster, c’est comme réunir des dizaines, voire des milliers d’ordinateurs (appelés nœuds) qui peuvent travailler ensemble sur de gros problèmes. C’est ce qu’on appelle le Calcul Haute Performance (HPC).
Indispensable pour la recherche : De nombreux domaines (physique, biologie, climatologie, intelligence artificielle…) dépendent des clusters pour faire avancer la science.
Imaginez une grande salle remplie d’ordinateurs spéciaux, tous connectés entre eux :
Les Nœuds de Calcul : Ce sont les "ouvriers". Chaque nœud est un ordinateur puissant qui effectue les calculs. Il y en a beaucoup !
Le Nœud de Connexion (Login Node) : C’est le "hall d’accueil" ou le "bureau de réception". C’est là que vous vous connectez pour préparer votre travail et le soumettre. IMPORTANT : Ce nœud n’est PAS fait pour faire de gros calculs ! Il est partagé par tous les utilisateurs.
Le Stockage Partagé : C’est là que vous stockez vos fichiers, vos programmes et les résultats de vos calculs. Il y a plusieurs types de stockages :
lent :
home : stockage lent et de faible volume, lisible depuis tous les noeuds, non accessible en lecture depuis les noeuds de calcul, pour vos fichiers personnels, vos fichiers de configuration
workspace : stockage lent, grand volume, partagé avec les personnes de votre groupe, lisible depuis tous les noeuds, non accessible en écriture depuis les noeuds de calcul, pour stocker et partager vos données sur le moyen et long terme
rapide :
scratch : stockage rapide, volume important, partagé avec les personnes de votre groupe, lisible depuis tous les noeuds, accessible en écriture depuis les noeuds de calcul, pour y placer les données qui doivent être lues et surtout les résultats de vos calculs.
TMPDIR : stockage ultra rapide, faible volume, créer au début d’un job et détruit à la fin du job,accessible en lecture et écriture uniquement depuis le job via la vraible $TMPDIR, pour y placer les données qui doivent être lues, les fichiers intermédiaire et les résultats lorsque la performance du stockage est importante
Le Réseau : Ce sont les "routes" qui connectent tous les nœuds entre eux et avec le stockage, pour qu’ils puissent communiquer rapidement. Un cluster de calcul a plusieurs réseau lents et rapide.
Imaginez maintenant des dizaines de personnes voulant utiliser les "ouvriers" (nœuds de calcul) en même temps. Ce serait le chaos ! Il faut un organisateur.
Le chef d’orchestre : Un gestionnaire de travaux, comme SLURM, agit comme un chef d’orchestre ou un maître d’hôtel. Il s’assure que les ressources (nœuds, CPU, mémoire) sont distribuées équitablement entre les utilisateurs.
La file d’attente : Il organise les demandes de calcul ("jobs") dans une file d’attente et les lance dès que les ressources nécessaires sont disponibles.
Sans lui, ce serait l’anarchie : Il évite que quelques utilisateurs monopolisent tout le cluster et permet à chacun d’avoir accès à la puissance de calcul.
SLURM (Simple Linux Utility for Resource Management) est le nom du gestionnaire de travaux que nous allons utiliser. C’est un logiciel très répandu sur les clusters de calcul dans le monde. Il est utilisé dans la grande majorité de mesocentre et des grands centres nationaux.
SLURM est le logiciel qui gère les ressources du cluster et exécute vos demandes de calcul (vos "jobs").
Il trouve les ressources (nœuds, cœurs de processeur, mémoire) dont vous avez besoin pour votre job.
Il met votre job dans une file d’attente s’il n’y a pas de place tout de suite.
Il lance votre job sur le(s) bon(s) nœud(s) de calcul quand c’est son tour.
Il surveille votre job pendant son exécution.
Il vous informe quand le job est terminé (ou s’il y a eu un problème).
Job : Votre demande de calcul. C’est l’unité de travail que vous soumettez à SLURM.
Partition (ou Queue) : Un groupe de nœuds de calcul. Imaginez différentes files d’attente au supermarché : une pour "moins de 10 articles" (rapide, pour petits tests), une "normale", une pour "gros caddies" (pour les longs calculs). Chaque partition a ses propres règles (temps max, nombre de nœuds max, etc.). Le nom des partitions disponibles auxuelles vous avez accès peux varier en fonction de vos projets de recherche ou groupe de travail !
Nœud (Node) : Un serveur (ordinateur) physique du cluster.
Tâche (Task / ntasks) : En général, cela correspond à un processus, c’est-à-dire une instance de votre programme en cours d’exécution. Pour un calcul simple, vous n’aurez souvent besoin que d’une seule tâche (ntasks=1).
CPU (ou Core / cpus-per-task) : Un "cœur" de processeur. C’est l’unité de base qui fait les calculs. Un nœud a plusieurs cœurs.
Mémoire (RAM / mem, mem-per-cpu) : La mémoire vive, l’espace de travail temporaire dont votre programme a besoin pour fonctionner.
Pour utiliser SLURM, il faut d’abord se connecter au cluster et savoir où mettre ses fichiers.
Vous utiliserez une commande appelée ssh (Secure Shell) depuis un terminal sur votre propre ordinateur. SSH crée une connexion sécurisée vers le nœud de connexion du cluster.
Ouvrez un terminal (sous Linux/macOS) ou un client SSH comme MobaXterm (sous Windows) et tapez :
ssh votre_login@adresse_du_cluster.fr
Remplacez votre_login par le nom d’utilisateur qui vous a été fourni.
Remplacez adresse_du_cluster.fr par l’adresse réseau du cluster (demandez-la à vos administrateurs).
On vous demandera votre mot de passe. Tapez-le (rien ne s’affichera à l’écran, c’est normal !) et appuyez sur Entrée.
Félicitations, vous êtes connecté au nœud de connexion du cluster !
IMPORTANT: IMPORTANT: mettre le lien vers la section NOTIONS des commandes
Une fois connecté, vous interagissez avec le cluster via des commandes Linux, comme celles que vous utilisez peut-être déjà. Voici les plus importantes à connaître :
pwd : Print Working Directory - Où suis-je actuellement ? Affiche le chemin complet de votre répertoire courant.
ls : LiSt - Qu’y a-t-il dans ce répertoire ? Affiche le contenu du répertoire courant. (ls -l pour plus de détails).
cd <nom_repertoire> : Change Directory - Se déplacer dans un autre répertoire. (cd .. pour remonter d’un niveau, cd tout seul pour revenir à votre répertoire personnel).
mkdir <nom_repertoire> : MaKe DIRectory - Créer un nouveau répertoire.
cp <source> <destination> : CoPy - Copier un fichier ou un répertoire.
mv <source> <destination> : MoVe - Déplacer ou renommer un fichier ou un répertoire.
rm <nom_fichier> : ReMove - Supprimer un fichier (Attention, pas de corbeille !).
Où mettre vos affaires ? Les clusters ont souvent différents espaces de stockage :
Votre répertoire personnel ($HOME) ou de groupe (workspace) : Accessible partout, permanent, mais peu rapide. Idéal pour vos scripts, codes sources, fichiers et résultats.
Espace scratch et TMPDIR : beacoup plus rapides, mais temporaire ! Les fichiers y sont effacés après un certain temps. Idéal pour les gros fichiers de données temporaires générés pendant vos calculs. voir la partie stockage
Sur les clusters, de nombreux logiciels (compilateurs, bibliothèques, applications scientifiques) sont installés en différentes versions. Pour éviter les conflits, on utilise un système de "modules". Imaginez un grand atelier avec plein d’outils : vous devez dire quels outils spécifiques vous voulez utiliser pour votre projet.
module avail : Liste tous les outils (modules) disponibles.
module load nom_du_module/version : Charge un outil spécifique dans votre environnement (ex: module load python/3.9.6).
module list : Affiche les modules que vous avez actuellement chargés.
module unload nom_du_module : Décharge un outil.
Pour notre premier script simple, nous n’aurons probablement pas besoin de charger de module, mais c’est bon à savoir pour la suite.
On ne lance pas un calcul directement en tapant la commande. On écrit un script qui décrit le calcul et les ressources dont il a besoin pour SLURM.
Un script SLURM est un simple fichier texte qui contient trois types de choses :
Le "Shebang" : La toute première ligne, qui commence par !. Elle indique quel interpréteur de commandes utiliser pour lire le reste du script (le plus souvent !/bin/bash).
Les Directives #SBATCH : Des lignes spéciales qui commencent par #SBATCH. Ce sont des instructions pour SLURM, pas pour votre calcul. Elles disent à SLURM combien de temps, de mémoire, de CPU, etc., votre job nécessite.
Vos Commandes : Les commandes Linux que vous voulez exécuter pour votre calcul (par exemple, lancer votre programme, manipuler des fichiers…).
#SBATCH)Voici quelques directives #SBATCH très courantes. Vous les placerez au début de votre script, juste après le shebang.
#SBATCH --job-name=MonCalcul : Donne un nom à votre job pour le retrouver facilement. Choisissez un nom descriptif.
#SBATCH --output=Resultat_%j.out : Indique le nom du fichier où sera écrite la sortie normale de vos commandes (ce qui s’afficherait à l’écran normalement). %j est un code spécial qui sera remplacé par l’ID unique de votre job. C’est pratique pour ne pas écraser les résultats de jobs précédents.
#SBATCH --error=Erreur_%j.err : Indique le nom du fichier où seront écrits les messages d’erreur. %j est aussi remplacé par l’ID du job. Très important pour comprendre ce qui n’a pas fonctionné !
#SBATCH --time=00:10:00 : Le temps maximum que vous réservez pour votre job (Format : heures:minutes:secondes). SLURM arrêtera votre job s’il dépasse ce temps. Commencez par une estimation large, puis affinez. Ici, on demande 10 minutes.
#SBATCH --nodes=1 : Combien de nœuds de calcul vous demandez. Pour débuter, 1 est souvent suffisant.
#SBATCH --ntasks=1 : Combien de tâches (processus) vous voulez lancer au total. Pour un programme simple non parallèle, 1 suffit.
#SBATCH --cpus-per-task=1 : Combien de cœurs CPU vous réservez pour chaque tâche. Pour un programme simple, 1 suffit.
#SBATCH --mem=500M : Combien de mémoire vive (RAM) vous réservez pour tout le job (ici, 500 Mégaoctets). Vous pouvez aussi utiliser G pour Gigaoctets (ex: --mem=4G). Il existe aussi --mem-per-cpu parfois. Demandez peu au début si vous ne savez pas.
#SBATCH --partition=debug : Très important ! Sur quelle partition (file d’attente) vous voulez soumettre votre job. Les noms (debug, compute, gpu, etc.) dépendent totalement de votre cluster. La partition debug est souvent limitée en temps mais permet d’avoir des résultats rapidement pour tester. Demandez aux administrateurs quelles partitions utiliser !
Créons un fichier texte (par exemple avec nano : nano premier_job.sh) et copions-y le contenu suivant. Adaptez le nom de la partition (--partition) !
#!/bin/bash
#_______________________________________________________________________________
# INSTRUCTIONS POUR SLURM
#_______________________________________________________________________________
#SBATCH --job-name=BonjourCluster # Nom du job (pour le retrouver facilement)
#SBATCH --output=Resultat_Bonjour_%j.out # Fichier de sortie standard (%j = ID du job)
#SBATCH --error=Erreur_Bonjour_%j.err # Fichier de sortie d'erreur (%j = ID du job)
#SBATCH --time=00:02:00 # Temps max d'exécution (HH:MM:SS) - ici 2 minutes
#SBATCH --nodes=1 # Nombre de nœuds requis
#SBATCH --ntasks=1 # Nombre total de tâches (processus)
#SBATCH --cpus-per-task=1 # Nombre de cœurs CPU par tâche
#SBATCH --mem=50M # Mémoire requise par le job (ex: 50 Mo)
#SBATCH --partition=debug # !!! ADAPTER LE NOM DE LA PARTITION À VOTRE CLUSTER !!!
#_______________________________________________________________________________
# COMMANDES À EXÉCUTER PAR LE JOB
#_______________________________________________________________________________
echo "------------------------------------------------------"
echo "Message du Job : Bonjour depuis le cluster !"
echo "Ce job tourne sur le noeud : $(hostname)" # Affiche le nom du noeud de calcul
echo "Lancé le : $(date)" # Affiche la date et l'heure
echo "------------------------------------------------------"
# On simule un petit travail qui dure 20 secondes
echo "Le job va maintenant 'travailler' pendant 20 secondes..."
sleep 20
echo "Le 'travail' est terminé."
echo "------------------------------------------------------"
echo "Fin du job le : $(date)"
echo "------------------------------------------------------"
Explication rapide : Les lignes #SBATCH donnent les instructions à SLURM. Les lignes echo affichent des messages. hostname affiche le nom de la machine où le script s’exécute (ce sera un nœud de calcul, pas le nœud de connexion !). date affiche l’heure. sleep 20 fait une pause de 20 secondes pour simuler un calcul.
Enregistrez le fichier (avec nano : Ctrl+O, Entrée, puis Ctrl+X).
Maintenant que le script est prêt, disons à SLURM de le prendre en charge !
sbatchDans le terminal, tapez simplement :
sbatch premier_job.sh
SLURM va lire votre script et, s'il est correct, répondre quelque chose comme :
Submitted batch job 12345
Le numéro `12345` est l'**ID de votre job**. C'est son numéro d'identification unique. **Notez-le ou retenez-le !**
squeuePour voir l'état de vos jobs (ceux qui sont en attente ou en cours d'exécution), utilisez la commande `squeue`. Pour ne voir que vos propres jobs :
squeue -u votre_login
(Remplacez votre_login). Vous verrez une ligne par job avec des informations comme :
JOBID : L’ID du job.
PARTITION : La partition demandée.
NAME : Le nom du job (--job-name).
USER : Votre nom d’utilisateur.
ST : L'état du job. Les plus courants :
PD (Pending) : Votre job est en attente. Il attend que les ressources (nœuds, CPU…) se libèrent ou que sa priorité soit suffisante. Soyez patient !
R (Running) : Votre job est en cours d’exécution sur un nœud de calcul.
CD (Completed) : Votre job est terminé avec succès. (Il disparaît rapidement de squeue).
F (Failed) : Votre job a échoué. Il faudra regarder les fichiers d’erreur.
CA (Cancelled) : Vous (ou un admin) avez annulé le job.
TIME : Le temps écoulé depuis le début de l’exécution.
NODES : Le nombre de nœuds utilisés.
NODELIST(REASON) : Sur quel(s) nœud(s) le job tourne (si R), ou la raison pour laquelle il est en attente (si PD, par exemple "Resources" ou "Priority").
scancelSi vous réalisez que vous avez fait une erreur dans votre script, ou si vous n’avez plus besoin du calcul, vous pouvez l’annuler avec scancel et son ID :
scancel 12345
(Remplacez `12345` par l'ID de votre job).
Attention : La commande scancel -u votre_login annule tous vos jobs en cours ou en attente. À utiliser avec précaution !
scontrol show job <job_id>Cette commande donne beaucoup d’informations sur un job (ressources demandées, temps utilisé, nœud d’exécution, etc.).
sinfoCette commande montre l'état des différentes partitions et des nœuds (disponibles, occupés...).
Une fois que votre job n’apparaît plus dans squeue -u votre_login (ou si son état est CD, F ou CA), vous pouvez aller voir ce qu’il a produit.
.out et .errRappelez-vous des directives --output et --error dans votre script ?
#SBATCH --output=Resultat_Bonjour_%j.out
#SBATCH --error=Erreur_Bonjour_%j.err
SLURM a créé ces fichiers en remplaçant %j par l’ID de votre job. Si votre job avait l’ID 12345, vous trouverez dans le répertoire où vous avez soumis le script :
* Resultat_Bonjour_12345.out : Contient tout ce que vos commandes ont affiché en sortie standard (les messages des echo, par exemple).
* Erreur_Bonjour_12345.err : Contient tous les messages d’erreur générés par vos commandes. C’est le premier fichier à regarder si votre job a échoué (F) ! S’il est vide, c’est bon signe.
Utilisez les commandes cat, less ou more pour lire le contenu de ces fichiers :
less Resultat_Bonjour_12345.out
less Erreur_Bonjour_12345.err
(Appuyez sur q pour quitter less).
Erreur dans le script SLURM : Une faute de frappe dans une directive #SBATCH (SLURM le refuse souvent dès la soumission avec sbatch).
Erreur dans vos commandes : Votre programme a planté, une commande Linux était incorrecte… Regardez le fichier .err.
Temps dépassé : Le job a duré plus longtemps que le --time demandé. Augmentez la limite de temps si nécessaire. Le fichier .err ou .out peut s’arrêter brusquement.
Mémoire dépassée : Le job a essayé d’utiliser plus de RAM que le --mem demandé. SLURM l’a tué. Augmentez la limite de mémoire. L’erreur apparaît souvent dans le fichier .err.
Partition incorrecte / Ressources indisponibles : Mauvais nom de partition, ou demande de ressources irréaliste pour la partition choisie.
Problème de fichiers : Fichiers d’entrée non trouvés, permissions incorrectes…
Si vous êtes bloqué, n’hésitez pas à :
Consulter la documentation officielle de SLURM
Demander de l’aide au support informatique.
Discuter avec des collègues plus expérimentés !!!
Utiliser un cluster est un privilège partagé. Voici quelques règles simples :
Le nœud de connexion est sacré : N’y lancez jamais de calculs longs ou gourmands ! Utilisez-le uniquement pour éditer des fichiers, compiler, soumettre des jobs (sbatch), et vérifier des résultats rapides.
Soyez raisonnable : Ne demandez pas plus de temps, de CPU ou de mémoire que nécessaire. Cela bloque les ressources pour les autres. Estimez au mieux, et ajustez si besoin.
Lisez la doc locale : Chaque cluster a ses spécificités. Prenez le temps de lire la documentation fournie par vos administrateurs.
Faites le ménage : Les espaces de stockage ne sont pas illimités. Supprimez régulièrement les fichiers de résultats ou temporaires dont vous n’avez plus besoin.
Jobs interactifs : Parfois, on a besoin d’interagir directement avec un nœud de calcul (pour du débogage, ou utiliser un logiciel graphique). Les commandes srun ou salloc permettent cela.
Tableaux de jobs (Job Arrays) : Très pratique pour lancer la même tâche sur plein de fichiers différents (par exemple, analyser 100 fichiers de données). On utilise l’option --array.
Utiliser des logiciels spécifiques : Apprenez à bien utiliser les module load pour vos applications scientifiques.
Dépendances entre jobs : Dire à SLURM de ne lancer un job que si un autre est terminé avec succès.
Voici les commandes que vous avez rencontrées et qui vous seront le plus utiles au début :
ssh login@cluster : Se connecter.
pwd, ls, cd, mkdir, cp, mv, rm : Gestion de fichiers de base.
module avail, module load, module list : Gérer les logiciels (si applicable).
nano (ou vi, vim) : Éditer vos scripts.
sbatch mon_script.sh : Soumettre un job.
squeue -u votre_login : Voir l’état de vos jobs.
scancel <job_id> : Annuler un job.
cat, less : Lire les fichiers de sortie et d’erreur.
IMPORTANT:
[Ajouter ici un lien vers la documentation SLURM officielle : https://slurm.schedmd.com/ et remonter la référence dans ce cours]
[Ajouter ici un contact pour le support zammad]
[Ajouter le lien vers le glossaire]