Formation OpenPBS

Programme de notre formation OpenPBS

[Jour 1 – Matin]

Comprendre le fonctionnement et l'architecture d'OpenPBS

• Situer OpenPBS dans un environnement HPC et distinguer les projets et offres de la famille PBS
• Comprendre les principes du traitement par lots : soumission, mise en attente, allocation des ressources et exécution
• Identifier les composants : pbs_server, pbs_sched, pbs_comm et pbs_mom
• Distinguer serveur de gestion, hôte de soumission, nœud de calcul et nœud virtuel PBS (vnode)
• Repérer les interactions entre utilisateurs, files d'attente, travaux et ressources
• Atelier pratique : cartographier un cluster pédagogique et retracer le parcours d'un travail depuis sa soumission jusqu'à sa fin d'exécution.

Préparer l'environnement et installer OpenPBS

• Vérifier les prérequis Linux : noms d'hôtes et FQDN, résolution de noms, comptes, permissions et connectivité
• Comparer l'installation à partir de paquets RPM et la compilation à partir des sources
• Identifier les dépendances nécessaires, notamment PostgreSQL pour le stockage des données du serveur
• Installer OpenPBS sur la distribution du laboratoire et repérer les adaptations pour Ubuntu
• Configurer les services dans /etc/pbs.conf, préparer l'environnement des commandes et vérifier le démarrage
• Atelier pratique : installer un serveur OpenPBS, contrôler ses services et vérifier son accessibilité avec les commandes PBS.

[Jour 1 – Après-midi]

Configurer les nœuds d'exécution et les ressources du cluster

• Configurer le service MOM sur les nœuds de calcul et vérifier la communication avec le serveur
• Enregistrer les nœuds avec qmgr et consulter leur état avec pbsnodes
• Distinguer ressources disponibles, ressources affectées et demandes formulées par les travaux
• Déclarer et vérifier les ressources de calcul : processeurs, mémoire et propriétés des nœuds
• Contrôler les comptes, les répertoires de travail et l'accès aux données nécessaires à l'exécution
• Atelier pratique : rattacher les nœuds au serveur, vérifier les ressources déclarées et exécuter un premier travail de validation.

Administrer les files d'attente et les accès

• Utiliser qmgr pour consulter et modifier les attributs du serveur et des files d'attente
• Distinguer les files d'exécution et les files de routage
• Définir les ressources par défaut et les limites applicables aux travaux
• Configurer les droits d'accès et distinguer les rôles d'utilisateur, d'opérateur et d'administrateur
• Comprendre la différence entre une file autorisant les nouvelles soumissions et une file autorisant l'exécution des travaux
• Atelier pratique : créer deux files adaptées à des usages différents, définir leurs limites et tester des soumissions conformes ou refusées.

[Jour 2 – Matin]

Rédiger des scripts batch PBS et demander les ressources adaptées

• Structurer un script shell PBS avec les directives #PBS et les commandes de calcul
• Définir le nom du travail, la file cible, les sorties standard et les sorties d'erreur
• Exprimer les besoins avec select, ncpus, mem et walltime
• Comprendre le placement des ressources avec place et la notion de groupe de ressources demandé (chunk)
• Préparer le répertoire de travail, les variables d'environnement et les logiciels nécessaires
• Atelier pratique : rédiger et soumettre un script PBS, puis ajuster ses demandes de ressources à partir des résultats d'exécution.

Gérer le cycle de vie des travaux

• Soumettre un travail avec qsub et examiner ses attributs avec qstat et qstat -f
• Interpréter les états des travaux et rechercher les raisons d'une attente
• Modifier les attributs autorisés avec qalter, placer un travail en attente avec qhold et le libérer avec qrls
• Supprimer un travail avec qdel et comprendre les conséquences sur son exécution
• Utiliser les dépendances entre travaux et les tableaux de travaux (job arrays) pour organiser une campagne de calcul
• Atelier pratique : lancer une série de calculs paramétrés, enchaîner une étape de traitement et corriger un travail bloqué en attente.

[Jour 2 – Après-midi]

Exécuter des applications parallèles avec OpenMP et MPI

• Distinguer calcul séquentiel, parallélisme à mémoire partagée avec OpenMP et calcul distribué avec MPI
• Mettre en cohérence les ressources PBS demandées avec les threads et les processus de l'application
• Utiliser les paramètres ompthreads et mpiprocs selon le type de calcul
• Adapter le lancement MPI à l'environnement installé et comprendre le rôle de PBS_NODEFILE
• Repérer les erreurs courantes : surallocation, nombre de processus incorrect et environnement logiciel incohérent
• Atelier pratique : exécuter un exemple OpenMP puis un exemple MPI et vérifier la cohérence entre allocation et utilisation des ressources.

Configurer les politiques d'ordonnancement

• Comprendre le cycle de décision de l'ordonnanceur et les contraintes qui conditionnent le démarrage d'un travail
• Examiner l'ordre d'arrivée, les priorités et les limites de consommation
• Comprendre le backfilling et l'importance de demandes de durée réalistes
• Découvrir le partage équitable (fairshare) pour répartir l'accès aux ressources entre utilisateurs ou groupes
• Modifier une politique simple et observer ses effets sur les temps d'attente et l'occupation du cluster
• Atelier pratique : soumettre des travaux concurrents, ajuster les paramètres d'ordonnancement et comparer l'ordre de démarrage obtenu.

[Jour 3 – Matin]

Superviser le cluster et diagnostiquer les incidents

• Suivre l'état des nœuds, des files et des travaux avec les commandes d'exploitation PBS
• Localiser et exploiter les journaux du serveur, de l'ordonnanceur et des démons MOM
• Retracer l'exécution d'un travail avec tracejob et consulter les informations de consommation disponibles
• Distinguer un problème de ressources, de communication, de droits, d'environnement ou d'application
• Mettre un nœud hors service pour maintenance et vérifier les conditions de sa remise à disposition
• Atelier pratique : diagnostiquer un nœud indisponible et un travail en échec, appliquer les corrections puis valider le retour au fonctionnement attendu.

Étendre les contrôles avec les hooks Python

• Comprendre le rôle des hooks et leur déclenchement lors d'événements du cycle de vie des travaux ou des nœuds
• Découvrir l'API Python PBS utilisée dans les hooks pour accéder au contexte d'un événement
• Examiner un contrôle de soumission : vérifier une demande et produire un message de refus explicite
• Identifier les usages des hooks pour les contrôles périodiques de santé des nœuds
• Tester un hook dans un environnement isolé, consulter ses journaux et prévoir sa désactivation
• Atelier pratique : adapter un hook Python fourni, tester une soumission acceptée puis refusée et vérifier les messages retournés.

[Jour 3 – Après-midi]

Découvrir l'intégration d'OpenPBS avec Azure CycleCloud

• Distinguer le rôle d'OpenPBS dans l'ordonnancement et celui de CycleCloud dans la gestion des machines cloud
• Identifier les composants d'un cluster OpenPBS déployé avec Azure CycleCloud
• Comprendre le rôle de l'agent azpbs et les principes de sa configuration
• Associer les demandes de ressources PBS aux caractéristiques des machines virtuelles
• Examiner les mécanismes de mise à l'échelle et les contraintes de quotas, de coûts et de disponibilité
• Atelier pratique guidé : analyser une configuration CycleCloud préparée et interpréter les décisions de mise à l'échelle à partir d'un scénario de charge.

Préparer la maintenance et valider l'exploitation du cluster

• Identifier les configurations et les données à sauvegarder avant une intervention
• Préparer une maintenance : maîtriser les nouvelles soumissions, traiter les travaux en cours et organiser l'arrêt des services
• Comprendre les principes de haute disponibilité et de basculement, ainsi que leurs prérequis d'infrastructure
• Distinguer reprise des services PBS, relance des travaux et reprise applicative à partir d'un point de contrôle
• Formaliser une procédure d'exploitation : vérifications, diagnostic, intervention et validation
• Atelier final : exécuter une campagne de calcul sur le cluster configuré, traiter un incident simulé et restituer les scripts, les réglages et la procédure d'exploitation.