Jobs interactifs avec Slurm

Un job interactif ouvre une session temporaire sur un nœud de calcul. Vous pouvez l'utiliser pour tester un logiciel, développer un code, vérifier un environnement ou exécuter un traitement court.

Sur eXplor-v2, une session interactive peut être lancée de trois façons complémentaires :

depuis un terminal avec salloc et srun ;
depuis SSH avec tmux, afin de conserver le terminal après une déconnexion ;
depuis le portail web Open OnDemand, avec l'application Interactive session via tmux.

Dans les trois cas, les ressources sont attribuées par Slurm. Une session interactive est donc un job qui consomme des CPU, de la mémoire et éventuellement un GPU.

Une session interactive consomme des ressources

Demandez uniquement les ressources et la durée nécessaires. Fermez ou annulez la session dès que vous avez terminé. N'exécutez pas de calcul directement sur un nœud de connexion.

Quelle méthode choisir ?

Méthode	Utilisation recommandée	Accès
`salloc` + `srun`	Ligne de commande, tests et développement avancé	SSH
`tmux` + `salloc`	Session conservée après une déconnexion SSH	SSH
Open OnDemand via tmux	Session interactive depuis un navigateur	Portail web
Job batch avec `sbatch`	Calcul long ou production	SSH ou Open OnDemand

Pour débuter

Si vous découvrez eXplor-v2, Open OnDemand via tmux offre un formulaire pour choisir les ressources. Si vous travaillez principalement en terminal ou si votre connexion SSH est instable, utilisez tmux avec une allocation Slurm.

Session interactive avec SSH

Lancer avec `salloc` et `srun`

Demandez une allocation interactive :

salloc \
  --partition=std \
  --ntasks=1 \
  --cpus-per-task=2 \
  --mem=4G \
  --time=00:15:00

Une fois l'allocation obtenue, ouvrez un shell sur le nœud attribué :

srun --pty bash

Vous pouvez aussi combiner les deux opérations :

salloc \
  --partition=std \
  --ntasks=1 \
  --cpus-per-task=2 \
  --mem=4G \
  --time=00:15:00 \
  srun --pty bash

Le nom std est fourni à titre d'exemple. Vérifiez les partitions disponibles et leurs limites avec :

sinfo

Vérifier l'allocation

Une fois le shell ouvert :

hostname
whoami
pwd

echo "$SLURM_JOB_ID"
echo "$SLURM_JOB_NODELIST"
echo "$SLURM_CPUS_PER_TASK"
echo "$SLURM_MEM_PER_NODE"

Vérifiez les ressources visibles :

nproc
free -h

Pour afficher les détails de l'allocation :

scontrol show job "$SLURM_JOB_ID"

Session CPU

Exemple de session CPU courte :

salloc \
  --partition=std \
  --ntasks=1 \
  --cpus-per-task=2 \
  --mem=4G \
  --time=00:15:00 \
  srun --pty bash

Pour un test très court, utilisez une partition de test ou de débogage si elle existe :

salloc \
  --partition=debug \
  --ntasks=1 \
  --cpus-per-task=2 \
  --mem=4G \
  --time=00:15:00 \
  srun --pty bash

Adaptez le nom de la partition, la durée et les ressources aux règles du cluster.

Session GPU

Exemple générique :

salloc \
  --partition=gpu \
  --ntasks=1 \
  --cpus-per-task=4 \
  --mem=16G \
  --gres=gpu:1 \
  --time=01:00:00 \
  srun --pty bash

Vérifiez ensuite le GPU attribué :

nvidia-smi

Pour obtenir le modèle et la mémoire :

nvidia-smi \
  --query-gpu=name,memory.total \
  --format=csv

Utiliser `tmux` avec SSH

tmux permet de conserver une session de terminal active après une déconnexion SSH. Il est utile lorsque la connexion réseau est instable ou lorsque vous devez revenir plus tard dans une session interactive.

tmux ne remplace pas Slurm

tmux protège le terminal, mais ne réserve aucune ressource et ne prolonge pas la durée de l'allocation. Le calcul doit être exécuté dans une allocation Slurm, sur un nœud de calcul.

Créer une session tmux

Après vous être connecté au cluster avec SSH, créez une session nommée :

tmux new -s interactive

Vérifiez que vous êtes dans tmux :

echo "$TMUX"

Une valeur non vide indique que le shell est exécuté dans tmux.

Demander l'allocation depuis tmux

Depuis la session tmux, demandez les ressources :

salloc \
  --partition=std \
  --ntasks=1 \
  --cpus-per-task=2 \
  --mem=4G \
  --time=02:00:00

Lorsque l'allocation est accordée, ouvrez un shell sur le nœud de calcul :

srun --pty bash

Vous pouvez aussi combiner l'allocation et le shell :

salloc \
  --partition=std \
  --ntasks=1 \
  --cpus-per-task=2 \
  --mem=4G \
  --time=02:00:00 \
  srun --pty bash

Vérifiez le nœud et l'allocation :

hostname
echo "$SLURM_JOB_ID"
echo "$SLURM_JOB_NODELIST"

La commande hostname doit afficher un nœud de calcul, et non un nœud de connexion.

Se détacher de tmux

Pour quitter temporairement la connexion sans arrêter tmux :

appuyez sur Ctrl+B ;
relâchez les touches ;
appuyez sur D.

La session est alors détachée. Le shell et les commandes continuent de s'exécuter tant que l'allocation Slurm est active.

Vous pouvez fermer la connexion SSH :

exit

La combinaison Ctrl+B

Ctrl+B est la touche préfixe par défaut de tmux. Les commandes D, C, N et P doivent être saisies après avoir relâché Ctrl+B.

Se reconnecter à tmux

Reconnectez-vous au cluster avec SSH, puis listez les sessions :

tmux ls

Rattachez-vous à la session :

tmux attach -t interactive

Ou utilisez la forme abrégée :

tmux a -t interactive

Vous retrouverez le shell et les programmes si l'allocation Slurm est toujours active.

Utiliser plusieurs sessions

Utilisez un nom distinct pour chaque travail :

tmux new -s test-python
tmux new -s test-gpu
tmux new -s debug

Lister les sessions :

tmux ls

Rattacher une session :

tmux attach -t test-gpu

Supprimer une session terminée :

tmux kill-session -t test-gpu

Commandes tmux utiles

Action	Commande
Créer une session nommée	`tmux new -s nom`
Lister les sessions	`tmux ls`
Se rattacher	`tmux attach -t nom`
Se détacher	`Ctrl+B`, puis `D`
Créer une fenêtre	`Ctrl+B`, puis `C`
Fenêtre suivante	`Ctrl+B`, puis `N`
Fenêtre précédente	`Ctrl+B`, puis `P`
Fermer le shell	`exit`
Supprimer une session	`tmux kill-session -t nom`

Exemple complet SSH + tmux

ssh <identifiant>@<hôte-de-connexion>
tmux new -s interactive

Depuis tmux :

salloc \
  --partition=std \
  --ntasks=1 \
  --cpus-per-task=4 \
  --mem=8G \
  --time=04:00:00 \
  srun --pty bash

Sur le nœud de calcul :

hostname
module load <module>
./mon-programme --input test.dat

Pour vous déconnecter sans interrompre la session :

Ctrl+B, puis D

Après une nouvelle connexion SSH :

tmux attach -t interactive

Open OnDemand via tmux

Open OnDemand propose l'application Interactive session via tmux. Elle permet de lancer une session batch interactive depuis un navigateur, avec un terminal maintenu par tmux.

Ouvrir l'application

Ouvrez le portail Open OnDemand.
Authentifiez-vous.
Ouvrez Interactive Apps.
Sélectionnez Interactive session via tmux.

Remplir le formulaire

Champ	Signification	Exemple
Compte	Projet ou compte Slurm rattaché au job	Votre projet
Partition Slurm	Ensemble de nœuds et règles choisi	`std`
Type de GPU	Modèle d'accélérateur demandé	`Aucun`
Nombre de cœurs CPU	CPU réservés à la session	`2` à `8`
Mémoire (Go)	RAM réservée	`4` à `32`
Durée maximale (heures)	Durée maximale du job	`1` à `4`

Pour une première session CPU, sélectionnez std, aucun GPU, peu de CPU, une mémoire raisonnable et une durée courte. Pour une session GPU, sélectionnez gpu et le modèle nécessaire si le formulaire le propose.

Le compte doit être autorisé

Le compte doit correspondre à un projet auquel vous êtes rattaché. Ne copiez pas automatiquement un compte visible dans une capture ou un exemple.

Lancer et ouvrir la session

Vérifiez les champs du formulaire.
Cliquez sur Launch.
Ouvrez My Interactive Sessions.
Attendez l'état Running.
Vérifiez le nombre de nœuds, de cœurs et le temps restant.
Cliquez sur Connect to tmux terminal.

La session peut rester en attente avant de passer à l'état Running.

Vérifier la session Open OnDemand

Dans le terminal ouvert par Open OnDemand, exécutez :

hostname
whoami
pwd

echo "$SLURM_JOB_ID"
echo "$SLURM_JOB_NODELIST"
echo "$SLURM_CPUS_PER_TASK"

Le nom affiché par hostname doit correspondre à un nœud de calcul.

Comparer les deux usages de tmux

Usage	Où tmux est créé ?	Comment l'allocation est-elle demandée ?	Connexion
SSH + tmux	Sur le nœud de connexion	Avec `salloc` et `srun`	Terminal SSH
Open OnDemand + tmux	Par l'application interactive	Par le formulaire Open OnDemand	Navigateur web

Dans les deux cas, tmux maintient le terminal, mais Slurm contrôle la durée et les ressources.

Tester un programme

Exécutez un test court :

./mon-programme --input test.dat

Pour un programme parallèle :

srun --ntasks=4 ./mon-programme --input test.dat

Pour un programme multithreadé :

export OMP_NUM_THREADS="$SLURM_CPUS_PER_TASK"

srun \
  --ntasks=1 \
  --cpus-per-task="$SLURM_CPUS_PER_TASK" \
  ./mon-programme --input test.dat

Si le test est concluant, préparez un script batch :

sbatch mon-calcul.slurm

Quitter correctement

Lorsque le travail est terminé :

arrêtez les programmes en cours ;
quittez le shell du nœud de calcul avec exit ;
vérifiez que le job n'est plus actif ;
annulez l'allocation si nécessaire ;
supprimez la session Open OnDemand si elle est encore affichée.

Depuis le terminal :

exit
squeue -u "$USER"

Annulez une allocation restante :

scancel <job_id>

Dans Open OnDemand, cliquez sur Delete pour arrêter une session encore active. Fermer l'onglet du navigateur ne suffit pas nécessairement.

Ne pas laisser une allocation inactive

Se détacher de tmux ne libère pas les ressources. Une allocation active continue de consommer les CPU, la mémoire ou les GPU réservés.

Dépannage

La session reste en attente

squeue -u "$USER"

Affichez la raison :

squeue \
  -j <job_id> \
  -o "%.18i %.9P %.20j %.8T %.10M %.10l %.6D %R"

Le bouton de connexion n'apparaît pas

Attendez l'état Running. Si la session échoue, consultez les détails affichés dans Open OnDemand.

Le terminal SSH se déconnecte

Reconnectez-vous et rattachez la session :

tmux ls
tmux attach -t interactive

Le terminal Open OnDemand se déconnecte

Retournez dans My Interactive Sessions et cliquez à nouveau sur Connect to tmux terminal, si le job est toujours actif.

Le GPU n'est pas visible

Vérifiez l'allocation :

scontrol show job <job_id>
nvidia-smi

Vérifiez que la partition, la demande de GPU et la syntaxe utilisée correspondent à la configuration eXplor-v2.

La session est interrompue

Consultez l'historique :

sacct \
  -j <job_id> \
  --format=JobID,JobName,State,Elapsed,Timelimit,MaxRSS,AllocTRES,ExitCode

Les causes possibles sont une limite de temps atteinte, un dépassement mémoire, une annulation ou un problème de nœud.

Bonnes pratiques

Demandez uniquement les ressources nécessaires.
Utilisez une partition de débogage pour les tests courts lorsqu'elle est disponible.
Créez tmux sur le nœud de connexion uniquement pour maintenir le terminal.
Exécutez les commandes de calcul dans l'allocation Slurm.
Vérifiez hostname après l'ouverture du shell.
Respectez la durée maximale demandée.
N'utilisez pas tmux pour contourner les limites Slurm.
Annulez explicitement les allocations terminées.
Passez à un job batch pour les calculs longs ou reproductibles.

Quelle méthode choisir ?​

Session interactive avec SSH​

Lancer avec salloc et srun​

Vérifier l'allocation​

Session CPU​

Session GPU​

Utiliser tmux avec SSH​

Créer une session tmux​

Demander l'allocation depuis tmux​

Se détacher de tmux​

Se reconnecter à tmux​

Utiliser plusieurs sessions​

Commandes tmux utiles​

Exemple complet SSH + tmux​

Open OnDemand via tmux​

Ouvrir l'application​

Remplir le formulaire​

Lancer et ouvrir la session​

Vérifier la session Open OnDemand​

Comparer les deux usages de tmux​

Tester un programme​

Quitter correctement​

Dépannage​

La session reste en attente​

Le bouton de connexion n'apparaît pas​

Le terminal SSH se déconnecte​

Le terminal Open OnDemand se déconnecte​

Le GPU n'est pas visible​

La session est interrompue​

Bonnes pratiques​

Pages associées​