Tutoriel : Gérer les comptes et la planification des tâches sur un cluster

Si vous êtes intéressé par les clusters d'entraînement Vertex AI, contactez votre représentant commercial pour y accéder.

Ce guide explique comment utiliser les fonctionnalités de comptabilité et de qualité de service (QoS) de Slurm pour gérer efficacement un cluster d'entraînement unique partagé par plusieurs équipes ayant des priorités et des besoins en ressources différents.

L'objectif

À la fin de ce tutoriel, vous disposerez d'un framework pour gérer les ressources de cluster qui peut :

Appliquez des limites de ressources par équipe.
Hiérarchisez et préemptez les tâches en fonction de leur urgence.
Fournir une comptabilité claire de la consommation des ressources.
Maximisez l'utilisation du cluster tout en maintenant l'équité.

Prérequis

Un cluster d'entraînement en cours d'exécution avec la comptabilité, la préemption et la priorité configurées pour gérer les comptes, planifier et hiérarchiser les jobs.
Orchestrer
Paramètres Slurm avancés
sudo sur le nœud de connexion du cluster pour exécuter les commandes d'administrateur.

Concepts clés : les éléments de base de la comptabilité Slurm

Slurm utilise une hiérarchie claire et flexible pour gérer les ressources. Il est essentiel de comprendre ces quatre éléments de base.

Composant	Exemple	Objectif
Compte	Une équipe ou un projet	Unité principale pour regrouper les utilisateurs et définir les limites de ressources globales (par exemple, `team_ace` peut utiliser un maximum de 10 nœuds).
Utilisateur	Un chercheur individuel	Personne qui envoie une tâche. Chaque utilisateur doit appartenir à un compte par défaut.
Partition	Une file d'attente matérielle	Regroupement logique de nœuds. Pour une flexibilité maximale, nous vous recommandons d'utiliser une seule partition contenant tous vos nœuds.
QOS	Un règlement	Ensemble nommé de règles qui définissent les limites des jobs (par exemple, "les jobs de cette QoS ne peuvent utiliser que deux nœuds") et la priorité de planification.

Avec ce modèle, vous pouvez définir un quota de haut niveau pour l'ensemble d'un compte et appliquer une limite par job plus précise à l'aide d'un QOS.

Personas : administrateur et chercheur

Deux rôles distincts interagissent avec ce système : l'administrateur de cluster et le chercheur.

Administrateur du cluster

Outil principal : sacctmgr (gestionnaire de compte Slurm)
Votre rôle : vous créez la "structure" des comptes, des utilisateurs et des règles de qualité de service. Il s'agit généralement d'une tâche de type "configurer une fois, mettre à jour si nécessaire".
Tâches clés : créer des comptes, y attribuer des utilisateurs, définir des manuels de règles de qualité de service et les associer.

Responsable d'études de marché

Outils principaux : sbatch, squeue, sinfo
Son rôle : envoyer et surveiller ses jobs de recherche.
La magie opère lorsque le chercheur envoie un job. Slurm vérifie automatiquement les règles associées à son compte et à sa qualité de service. Si le job enfreint une limite, Slurm le rejette avec un message d'erreur clair.

Tutoriel : procédure pas à pas progressive

Le tutoriel suivant met ces concepts en pratique à travers une série de scénarios progressifs. Pour ce tutoriel, supposez que vous êtes l'administrateur du cluster. Votre tâche consiste à configurer un compte, team_ace, et un utilisateur, user_alice. Les scénarios commencent sans limites et ajoutent progressivement des niveaux de contrôle.

Partie 1 : Configuration initiale (sans limites)

Créez le compte et associez-y l'utilisateur.

Objectif : créer la hiérarchie de base pour team_ace et user_alice.
Méthode : utilisez sacctmgr pour ajouter un compte, puis ajoutez un utilisateur associé à ce compte.

# --- (Run as Admin) ---

# 1. Create the 'team_ace' account
sudo sacctmgr add account team_ace Description="The Ace Team"

# 2. Create the 'user_alice' user and map them to their default account
# (Note: 'user_alice' must already exist as a Linux user on the node)
sudo sacctmgr add user user_alice Account=team_ace

# 3. Show the hierarchy we just built to confirm
sacctmgr show associations where account=team_ace

Résultat : En tant qu'utilisateur user_alice, vous pouvez désormais envoyer un job volumineux. Comme il n'y a pas de limites, une tâche à sept nœuds est acceptée et exécutée immédiatement (en supposant que sept nœuds soient inactifs).

Partie 2 : Ajouter des limites au niveau du groupe à un compte

Ensuite, appliquez une limite de ressources au compte team_ace, en limitant l'ensemble de l'équipe à un maximum de six nœuds et quatre tâches au total.

Objectif : définir une limite de ressources totale pour toute une équipe.
Méthode : nous appliquons cette limite au compte team_ace à l'aide de GrpJobs (Group Jobs) et GrpTRES (Group Trackable Resources, dans ce cas, node=6).

# --- (Run as Admin) ---

# 1. Add group-level job and node limits to the 'team_ace' account
sudo sacctmgr modify account where name=team_ace set GrpJobs=4 GrpTRES=node=6

# 2. View the limits to confirm the change
sacctmgr show association where account=team_ace

Résultats : pour vérifier que les nouvelles limites fonctionnent, effectuez les tests suivants en tant que user_alice :

Limite de nœuds : l'envoi d'un job à sept nœuds échoue désormais. La tâche est mise en état en attente (PD) avec la raison (AssocGrpNodeLimit).
Limite de tâches : si vous envoyez cinq tâches à un seul nœud, quatre tâches seront en cours d'exécution (R) et la cinquième sera en attente (PD) avec le motif (AssocGrpJobsLimit).

Les limites au niveau du compte fonctionnent parfaitement.

Partie 3 : Ajouter une limite par job avec la qualité de service

La limite de groupe au niveau du compte permet de plafonner l'utilisation totale des ressources d'une équipe. Toutefois, cela n'empêche pas un utilisateur d'envoyer un seul job qui consomme l'intégralité du quota de l'équipe. Pour contrôler la taille des jobs individuels, l'étape suivante consiste à utiliser une qualité de service (QoS).

Objectif : limiter la taille maximale de chaque job envoyé par l'équipe.
Méthode : nous allons créer une qualité de service (QoS) nommée qos1 avec une règle MaxTRESPerJob=node=2. Nous en ferons ensuite la QoS par défaut pour l'ensemble du compte team_ace.

# --- (Run as Admin) ---

# 1. Create a QOS with a per-job limit of 2 nodes
sudo sacctmgr add qos qos1 MaxTRESPerJob=node=2

# 2. Allow the 'team_ace' account to use this QOS
sudo sacctmgr modify account where account=team_ace set QOS=qos1

# 3. Set 'qos1' as the DEFAULT QOS for all users in this account
sudo sacctmgr modify account where account=team_ace set DefaultQOS=qos1

Résultat : Désormais, si user_alice envoie un job à trois nœuds, il est placé dans l'état "En attente" avec le motif (QOSMaxNodePerJobLimit). L'utilisateur respecte toujours son quota de compte total (six nœuds), mais il a enfreint la règle QoS par job.

Partie 4 : Ajouter un remplacement spécifique à un utilisateur

Que faire si user_alice est un stagiaire et que ses tâches doivent être encore plus limitées, sans affecter le reste de l'équipe ?

Objectif : appliquer une limite plus restrictive à un seul utilisateur.
Méthode : nous allons créer un nouveau QOS (qos_intern) plus restrictif et l'appliquer par défaut spécifiquement pour user_alice. Cela remplace la qualité de service par défaut du compte.


# --- (Run as Admin) ---

# 1. Create a more restrictive QOS with a 1-node limit
sudo sacctmgr add qos qos_intern MaxTRESPerJob=node=1

# 2. Allow the account to use this new QOS
sudo sacctmgr modify account where account=team_ace set QOS+=qos_intern

# 3. Apply 'qos_intern' as the default QOS for the specific user association
sudo sacctmgr modify user where name=user_alice account=team_ace set DefaultQOS=qos_intern

Résultat : si user_alice tente d'envoyer le job à deux nœuds qui était auparavant autorisé sous qos1, l'opération échoue (QOSMaxNodePerJobLimit). La règle plus spécifique au niveau de l'utilisateur a bien remplacé la règle générale au niveau du compte.

Partie 5 : Configurer la priorité et la préemption

Enfin, configurez la priorité et la préemption des jobs pour vous assurer que les jobs critiques peuvent s'exécuter immédiatement, même si le cluster est plein.

L'objectif : créer une QoS "urgente" à priorité élevée qui peut suspendre ou annuler un job de priorité inférieure pour libérer des ressources.
Méthode :
1. Créez un qos_urgent avec une valeur Priority élevée.
2. Indiquez à qos_urgent qu'il est autorisé à Preempt les jobs exécutés dans qos1.
3. Configurez qos1 pour REQUEUE ses jobs lorsqu'ils sont préemptés.


# --- (Run as Admin) ---

# 1. Create a new 'qos_urgent' with a high priority that can preempt 'qos1'
sudo sacctmgr add qos qos_urgent Priority=1000 Preempt=qos1

# 2. Configure 'qos1' to requeue preempted jobs after a 10-second grace period
sudo sacctmgr modify qos where name=qos1 set PreemptMode=REQUEUE GraceTime=10

# 3. Allow the 'team_ace' account and 'user_alice' to use this new QOS
sudo sacctmgr modify account where account=team_ace set QOS+=qos_urgent
sudo sacctmgr modify user where name=user_alice account=team_ace set QOS+=qos_urgent

# 4. For this scenario, remove the group limits so preemption is easier to trigger
sudo sacctmgr modify account where name=team_ace set GrpJobs=-1 GrpTRES=node=-1

Résultat :

Dans un terminal, user_alice envoie un job de longue durée avec la valeur par défaut qos1. Il commence à s'exécuter (R).
Dans un deuxième terminal, user_alice envoie un job volumineux à l'aide de la qualité de service (QoS) urgente (sbatch --qos=qos_urgent ...).
En quelques secondes, l'état du premier job passe de "en cours d'exécution" (R) à "en attente" (PD) avec le motif (Preempted). Le job urgent commence alors à s'exécuter.

Opération réussie ! Vous avez configuré un système dans lequel les tâches à priorité élevée remplacent automatiquement celles à faible priorité.

Résumé et étapes suivantes

En suivant ce tutoriel, vous avez appris à utiliser les fonctionnalités de comptabilité hiérarchique de Slurm pour contrôler précisément un cluster partagé. Vous pouvez effectuer les actions suivantes :

Définissez des limites globales : utilisez des comptes pour définir des quotas de ressources totales pour des équipes entières.
Appliquez des règles par job : utilisez la qualité de service pour contrôler la taille et la priorité des jobs individuels.
Créez des remplacements spécifiques : appliquez une qualité de service différente à un utilisateur pour un contrôle précis.
Garantissez la priorité : configurez la préemption pour vous assurer que les charges de travail critiques peuvent toujours s'exécuter.

Ce modèle en couches offre un moyen flexible et puissant de gérer les ressources du cluster de manière équitable et efficace. Pour des configurations encore plus avancées, consultez la documentation officielle de Slurm.

Tutoriel : Gérer les comptes et la planification des tâches sur un cluster Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.